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_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 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         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC883_3ST_2ch_DIG,
 212         ALC883_3ST_6ch_DIG,
 213         ALC883_3ST_6ch,
 214         ALC883_6ST_DIG,
 215         ALC883_TARGA_DIG,
 216         ALC883_TARGA_2ch_DIG,
 217         ALC883_TARGA_8ch_DIG,
 218         ALC883_ACER,
 219         ALC883_ACER_ASPIRE,
 220         ALC888_ACER_ASPIRE_4930G,
 221         ALC888_ACER_ASPIRE_6530G,
 222         ALC888_ACER_ASPIRE_8930G,
 223         ALC883_MEDION,
 224         ALC883_MEDION_MD2,
 225         ALC883_LAPTOP_EAPD,
 226         ALC883_LENOVO_101E_2ch,
 227         ALC883_LENOVO_NB0763,
 228         ALC888_LENOVO_MS7195_DIG,
 229         ALC888_LENOVO_SKY,
 230         ALC883_HAIER_W66,
 231         ALC888_3ST_HP,
 232         ALC888_6ST_DELL,
 233         ALC883_MITAC,
 234         ALC883_CLEVO_M720,
 235         ALC883_FUJITSU_PI2515,
 236         ALC888_FUJITSU_XA3530,
 237         ALC883_3ST_6ch_INTEL,
 238         ALC888_ASUS_M90V,
 239         ALC888_ASUS_EEE1601,
 240         ALC889A_MB31,
 241         ALC1200_ASUS_P5Q,
 242         ALC883_SONY_VAIO_TT,
 243         ALC882_AUTO,
 244         ALC882_MODEL_LAST,
 245 };
 246
 247 /* for GPIO Poll */
 248 #define GPIO_MASK       0x03
 249
 250 /* extra amp-initialization sequence types */
 251 enum {
 252         ALC_INIT_NONE,
 253         ALC_INIT_DEFAULT,
 254         ALC_INIT_GPIO1,
 255         ALC_INIT_GPIO2,
 256         ALC_INIT_GPIO3,
 257 };
 258
 259 struct alc_spec {
 260         /* codec parameterization */
 261         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 262         unsigned int num_mixers;
 263         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 264         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 265
 266         const struct hda_verb *init_verbs[5];   /* initialization verbs
 267                                                  * don't forget NULL
 268                                                  * termination!
 269                                                  */
 270         unsigned int num_init_verbs;
 271
 272         char stream_name_analog[16];    /* analog PCM stream */
 273         struct hda_pcm_stream *stream_analog_playback;
 274         struct hda_pcm_stream *stream_analog_capture;
 275         struct hda_pcm_stream *stream_analog_alt_playback;
 276         struct hda_pcm_stream *stream_analog_alt_capture;
 277
 278         char stream_name_digital[16];   /* digital PCM stream */
 279         struct hda_pcm_stream *stream_digital_playback;
 280         struct hda_pcm_stream *stream_digital_capture;
 281
 282         /* playback */
 283         struct hda_multi_out multiout;  /* playback set-up
 284                                          * max_channels, dacs must be set
 285                                          * dig_out_nid and hp_nid are optional
 286                                          */
 287         hda_nid_t alt_dac_nid;
 288         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 289         int dig_out_type;
 290
 291         /* capture */
 292         unsigned int num_adc_nids;
 293         hda_nid_t *adc_nids;
 294         hda_nid_t *capsrc_nids;
 295         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 296
 297         /* capture source */
 298         unsigned int num_mux_defs;
 299         const struct hda_input_mux *input_mux;
 300         unsigned int cur_mux[3];
 301
 302         /* channel model */
 303         const struct hda_channel_mode *channel_mode;
 304         int num_channel_mode;
 305         int need_dac_fix;
 306         int const_channel_count;
 307         int ext_channel_count;
 308
 309         /* PCM information */
 310         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 311
 312         /* dynamic controls, init_verbs and input_mux */
 313         struct auto_pin_cfg autocfg;
 314         struct snd_array kctls;
 315         struct hda_input_mux private_imux[3];
 316         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 317         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 318         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 319
 320         /* hooks */
 321         void (*init_hook)(struct hda_codec *codec);
 322         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 323
 324         /* for pin sensing */
 325         unsigned int sense_updated: 1;
 326         unsigned int jack_present: 1;
 327         unsigned int master_sw: 1;
 328
 329         /* other flags */
 330         unsigned int no_analog :1; /* digital I/O only */
 331         int init_amp;
 332
 333         /* for virtual master */
 334         hda_nid_t vmaster_nid;
 335 #ifdef CONFIG_SND_HDA_POWER_SAVE
 336         struct hda_loopback_check loopback;
 337 #endif
 338
 339         /* for PLL fix */
 340         hda_nid_t pll_nid;
 341         unsigned int pll_coef_idx, pll_coef_bit;
 342 };
 343
 344 /*
 345  * configuration template - to be copied to the spec instance
 346  */
 347 struct alc_config_preset {
 348         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 349                                              * with spec
 350                                              */
 351         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 352         const struct hda_verb *init_verbs[5];
 353         unsigned int num_dacs;
 354         hda_nid_t *dac_nids;
 355         hda_nid_t dig_out_nid;          /* optional */
 356         hda_nid_t hp_nid;               /* optional */
 357         hda_nid_t *slave_dig_outs;
 358         unsigned int num_adc_nids;
 359         hda_nid_t *adc_nids;
 360         hda_nid_t *capsrc_nids;
 361         hda_nid_t dig_in_nid;
 362         unsigned int num_channel_mode;
 363         const struct hda_channel_mode *channel_mode;
 364         int need_dac_fix;
 365         int const_channel_count;
 366         unsigned int num_mux_defs;
 367         const struct hda_input_mux *input_mux;
 368         void (*unsol_event)(struct hda_codec *, unsigned int);
 369         void (*init_hook)(struct hda_codec *);
 370 #ifdef CONFIG_SND_HDA_POWER_SAVE
 371         struct hda_amp_list *loopbacks;
 372 #endif
 373 };
 374
 375
 376 /*
 377  * input MUX handling
 378  */
 379 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 380                              struct snd_ctl_elem_info *uinfo)
 381 {
 382         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 383         struct alc_spec *spec = codec->spec;
 384         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 385         if (mux_idx >= spec->num_mux_defs)
 386                 mux_idx = 0;
 387         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 388 }
 389
 390 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 391                             struct snd_ctl_elem_value *ucontrol)
 392 {
 393         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 394         struct alc_spec *spec = codec->spec;
 395         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 396
 397         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 398         return 0;
 399 }
 400
 401 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 402                             struct snd_ctl_elem_value *ucontrol)
 403 {
 404         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 405         struct alc_spec *spec = codec->spec;
 406         const struct hda_input_mux *imux;
 407         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 408         unsigned int mux_idx;
 409         hda_nid_t nid = spec->capsrc_nids ?
 410                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 411         unsigned int type;
 412
 413         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 414         imux = &spec->input_mux[mux_idx];
 415
 416         type = (get_wcaps(codec, nid) & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
 417         if (type == AC_WID_AUD_MIX) {
 418                 /* Matrix-mixer style (e.g. ALC882) */
 419                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 420                 unsigned int i, idx;
 421
 422                 idx = ucontrol->value.enumerated.item[0];
 423                 if (idx >= imux->num_items)
 424                         idx = imux->num_items - 1;
 425                 if (*cur_val == idx)
 426                         return 0;
 427                 for (i = 0; i < imux->num_items; i++) {
 428                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 429                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 430                                                  imux->items[i].index,
 431                                                  HDA_AMP_MUTE, v);
 432                 }
 433                 *cur_val = idx;
 434                 return 1;
 435         } else {
 436                 /* MUX style (e.g. ALC880) */
 437                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 438                                              &spec->cur_mux[adc_idx]);
 439         }
 440 }
 441
 442 /*
 443  * channel mode setting
 444  */
 445 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 446                             struct snd_ctl_elem_info *uinfo)
 447 {
 448         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 449         struct alc_spec *spec = codec->spec;
 450         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 451                                     spec->num_channel_mode);
 452 }
 453
 454 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 455                            struct snd_ctl_elem_value *ucontrol)
 456 {
 457         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 458         struct alc_spec *spec = codec->spec;
 459         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 460                                    spec->num_channel_mode,
 461                                    spec->ext_channel_count);
 462 }
 463
 464 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 465                            struct snd_ctl_elem_value *ucontrol)
 466 {
 467         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 468         struct alc_spec *spec = codec->spec;
 469         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 470                                       spec->num_channel_mode,
 471                                       &spec->ext_channel_count);
 472         if (err >= 0 && !spec->const_channel_count) {
 473                 spec->multiout.max_channels = spec->ext_channel_count;
 474                 if (spec->need_dac_fix)
 475                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 476         }
 477         return err;
 478 }
 479
 480 /*
 481  * Control the mode of pin widget settings via the mixer.  "pc" is used
 482  * instead of "%" to avoid consequences of accidently treating the % as
 483  * being part of a format specifier.  Maximum allowed length of a value is
 484  * 63 characters plus NULL terminator.
 485  *
 486  * Note: some retasking pin complexes seem to ignore requests for input
 487  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 488  * are requested.  Therefore order this list so that this behaviour will not
 489  * cause problems when mixer clients move through the enum sequentially.
 490  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 491  * March 2006.
 492  */
 493 static char *alc_pin_mode_names[] = {
 494         "Mic 50pc bias", "Mic 80pc bias",
 495         "Line in", "Line out", "Headphone out",
 496 };
 497 static unsigned char alc_pin_mode_values[] = {
 498         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 499 };
 500 /* The control can present all 5 options, or it can limit the options based
 501  * in the pin being assumed to be exclusively an input or an output pin.  In
 502  * addition, "input" pins may or may not process the mic bias option
 503  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 504  * accept requests for bias as of chip versions up to March 2006) and/or
 505  * wiring in the computer.
 506  */
 507 #define ALC_PIN_DIR_IN              0x00
 508 #define ALC_PIN_DIR_OUT             0x01
 509 #define ALC_PIN_DIR_INOUT           0x02
 510 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 511 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 512
 513 /* Info about the pin modes supported by the different pin direction modes.
 514  * For each direction the minimum and maximum values are given.
 515  */
 516 static signed char alc_pin_mode_dir_info[5][2] = {
 517         { 0, 2 },    /* ALC_PIN_DIR_IN */
 518         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 519         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 520         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 521         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 522 };
 523 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 524 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 525 #define alc_pin_mode_n_items(_dir) \
 526         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 527
 528 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 529                              struct snd_ctl_elem_info *uinfo)
 530 {
 531         unsigned int item_num = uinfo->value.enumerated.item;
 532         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 533
 534         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 535         uinfo->count = 1;
 536         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 537
 538         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 539                 item_num = alc_pin_mode_min(dir);
 540         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 541         return 0;
 542 }
 543
 544 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 545                             struct snd_ctl_elem_value *ucontrol)
 546 {
 547         unsigned int i;
 548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 549         hda_nid_t nid = kcontrol->private_value & 0xffff;
 550         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 551         long *valp = ucontrol->value.integer.value;
 552         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 553                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 554                                                  0x00);
 555
 556         /* Find enumerated value for current pinctl setting */
 557         i = alc_pin_mode_min(dir);
 558         while (alc_pin_mode_values[i] != pinctl && i <= alc_pin_mode_max(dir))
 559                 i++;
 560         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 561         return 0;
 562 }
 563
 564 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 565                             struct snd_ctl_elem_value *ucontrol)
 566 {
 567         signed int change;
 568         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 569         hda_nid_t nid = kcontrol->private_value & 0xffff;
 570         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 571         long val = *ucontrol->value.integer.value;
 572         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 573                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 574                                                  0x00);
 575
 576         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 577                 val = alc_pin_mode_min(dir);
 578
 579         change = pinctl != alc_pin_mode_values[val];
 580         if (change) {
 581                 /* Set pin mode to that requested */
 582                 snd_hda_codec_write_cache(codec, nid, 0,
 583                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 584                                           alc_pin_mode_values[val]);
 585
 586                 /* Also enable the retasking pin's input/output as required
 587                  * for the requested pin mode.  Enum values of 2 or less are
 588                  * input modes.
 589                  *
 590                  * Dynamically switching the input/output buffers probably
 591                  * reduces noise slightly (particularly on input) so we'll
 592                  * do it.  However, having both input and output buffers
 593                  * enabled simultaneously doesn't seem to be problematic if
 594                  * this turns out to be necessary in the future.
 595                  */
 596                 if (val <= 2) {
 597                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 598                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 599                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 600                                                  HDA_AMP_MUTE, 0);
 601                 } else {
 602                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 603                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 604                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 605                                                  HDA_AMP_MUTE, 0);
 606                 }
 607         }
 608         return change;
 609 }
 610
 611 #define ALC_PIN_MODE(xname, nid, dir) \
 612         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 613           .info = alc_pin_mode_info, \
 614           .get = alc_pin_mode_get, \
 615           .put = alc_pin_mode_put, \
 616           .private_value = nid | (dir<<16) }
 617
 618 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 619  * together using a mask with more than one bit set.  This control is
 620  * currently used only by the ALC260 test model.  At this stage they are not
 621  * needed for any "production" models.
 622  */
 623 #ifdef CONFIG_SND_DEBUG
 624 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 625
 626 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 627                              struct snd_ctl_elem_value *ucontrol)
 628 {
 629         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 630         hda_nid_t nid = kcontrol->private_value & 0xffff;
 631         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 632         long *valp = ucontrol->value.integer.value;
 633         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 634                                               AC_VERB_GET_GPIO_DATA, 0x00);
 635
 636         *valp = (val & mask) != 0;
 637         return 0;
 638 }
 639 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 640                              struct snd_ctl_elem_value *ucontrol)
 641 {
 642         signed int change;
 643         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 644         hda_nid_t nid = kcontrol->private_value & 0xffff;
 645         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 646         long val = *ucontrol->value.integer.value;
 647         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 648                                                     AC_VERB_GET_GPIO_DATA,
 649                                                     0x00);
 650
 651         /* Set/unset the masked GPIO bit(s) as needed */
 652         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 653         if (val == 0)
 654                 gpio_data &= ~mask;
 655         else
 656                 gpio_data |= mask;
 657         snd_hda_codec_write_cache(codec, nid, 0,
 658                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 659
 660         return change;
 661 }
 662 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 663         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 664           .info = alc_gpio_data_info, \
 665           .get = alc_gpio_data_get, \
 666           .put = alc_gpio_data_put, \
 667           .private_value = nid | (mask<<16) }
 668 #endif   /* CONFIG_SND_DEBUG */
 669
 670 /* A switch control to allow the enabling of the digital IO pins on the
 671  * ALC260.  This is incredibly simplistic; the intention of this control is
 672  * to provide something in the test model allowing digital outputs to be
 673  * identified if present.  If models are found which can utilise these
 674  * outputs a more complete mixer control can be devised for those models if
 675  * necessary.
 676  */
 677 #ifdef CONFIG_SND_DEBUG
 678 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 679
 680 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 681                               struct snd_ctl_elem_value *ucontrol)
 682 {
 683         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 684         hda_nid_t nid = kcontrol->private_value & 0xffff;
 685         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 686         long *valp = ucontrol->value.integer.value;
 687         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 688                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 689
 690         *valp = (val & mask) != 0;
 691         return 0;
 692 }
 693 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 694                               struct snd_ctl_elem_value *ucontrol)
 695 {
 696         signed int change;
 697         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 698         hda_nid_t nid = kcontrol->private_value & 0xffff;
 699         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 700         long val = *ucontrol->value.integer.value;
 701         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 702                                                     AC_VERB_GET_DIGI_CONVERT_1,
 703                                                     0x00);
 704
 705         /* Set/unset the masked control bit(s) as needed */
 706         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 707         if (val==0)
 708                 ctrl_data &= ~mask;
 709         else
 710                 ctrl_data |= mask;
 711         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 712                                   ctrl_data);
 713
 714         return change;
 715 }
 716 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 717         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 718           .info = alc_spdif_ctrl_info, \
 719           .get = alc_spdif_ctrl_get, \
 720           .put = alc_spdif_ctrl_put, \
 721           .private_value = nid | (mask<<16) }
 722 #endif   /* CONFIG_SND_DEBUG */
 723
 724 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 725  * Again, this is only used in the ALC26x test models to help identify when
 726  * the EAPD line must be asserted for features to work.
 727  */
 728 #ifdef CONFIG_SND_DEBUG
 729 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 730
 731 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 732                               struct snd_ctl_elem_value *ucontrol)
 733 {
 734         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 735         hda_nid_t nid = kcontrol->private_value & 0xffff;
 736         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 737         long *valp = ucontrol->value.integer.value;
 738         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 739                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 740
 741         *valp = (val & mask) != 0;
 742         return 0;
 743 }
 744
 745 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 746                               struct snd_ctl_elem_value *ucontrol)
 747 {
 748         int change;
 749         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 750         hda_nid_t nid = kcontrol->private_value & 0xffff;
 751         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 752         long val = *ucontrol->value.integer.value;
 753         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 754                                                     AC_VERB_GET_EAPD_BTLENABLE,
 755                                                     0x00);
 756
 757         /* Set/unset the masked control bit(s) as needed */
 758         change = (!val ? 0 : mask) != (ctrl_data & mask);
 759         if (!val)
 760                 ctrl_data &= ~mask;
 761         else
 762                 ctrl_data |= mask;
 763         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 764                                   ctrl_data);
 765
 766         return change;
 767 }
 768
 769 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 770         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 771           .info = alc_eapd_ctrl_info, \
 772           .get = alc_eapd_ctrl_get, \
 773           .put = alc_eapd_ctrl_put, \
 774           .private_value = nid | (mask<<16) }
 775 #endif   /* CONFIG_SND_DEBUG */
 776
 777 /*
 778  * set up the input pin config (depending on the given auto-pin type)
 779  */
 780 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 781                               int auto_pin_type)
 782 {
 783         unsigned int val = PIN_IN;
 784
 785         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 786                 unsigned int pincap;
 787                 pincap = snd_hda_query_pin_caps(codec, nid);
 788                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 789                 if (pincap & AC_PINCAP_VREF_80)
 790                         val = PIN_VREF80;
 791                 else if (pincap & AC_PINCAP_VREF_50)
 792                         val = PIN_VREF50;
 793                 else if (pincap & AC_PINCAP_VREF_100)
 794                         val = PIN_VREF100;
 795                 else if (pincap & AC_PINCAP_VREF_GRD)
 796                         val = PIN_VREFGRD;
 797         }
 798         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 799 }
 800
 801 /*
 802  */
 803 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 804 {
 805         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 806                 return;
 807         spec->mixers[spec->num_mixers++] = mix;
 808 }
 809
 810 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 811 {
 812         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 813                 return;
 814         spec->init_verbs[spec->num_init_verbs++] = verb;
 815 }
 816
 817 #ifdef CONFIG_PROC_FS
 818 /*
 819  * hook for proc
 820  */
 821 static void print_realtek_coef(struct snd_info_buffer *buffer,
 822                                struct hda_codec *codec, hda_nid_t nid)
 823 {
 824         int coeff;
 825
 826         if (nid != 0x20)
 827                 return;
 828         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 829         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 830         coeff = snd_hda_codec_read(codec, nid, 0,
 831                                    AC_VERB_GET_COEF_INDEX, 0);
 832         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 833 }
 834 #else
 835 #define print_realtek_coef      NULL
 836 #endif
 837
 838 /*
 839  * set up from the preset table
 840  */
 841 static void setup_preset(struct alc_spec *spec,
 842                          const struct alc_config_preset *preset)
 843 {
 844         int i;
 845
 846         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 847                 add_mixer(spec, preset->mixers[i]);
 848         spec->cap_mixer = preset->cap_mixer;
 849         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 850              i++)
 851                 add_verb(spec, preset->init_verbs[i]);
 852
 853         spec->channel_mode = preset->channel_mode;
 854         spec->num_channel_mode = preset->num_channel_mode;
 855         spec->need_dac_fix = preset->need_dac_fix;
 856         spec->const_channel_count = preset->const_channel_count;
 857
 858         if (preset->const_channel_count)
 859                 spec->multiout.max_channels = preset->const_channel_count;
 860         else
 861                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 862         spec->ext_channel_count = spec->channel_mode[0].channels;
 863
 864         spec->multiout.num_dacs = preset->num_dacs;
 865         spec->multiout.dac_nids = preset->dac_nids;
 866         spec->multiout.dig_out_nid = preset->dig_out_nid;
 867         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 868         spec->multiout.hp_nid = preset->hp_nid;
 869
 870         spec->num_mux_defs = preset->num_mux_defs;
 871         if (!spec->num_mux_defs)
 872                 spec->num_mux_defs = 1;
 873         spec->input_mux = preset->input_mux;
 874
 875         spec->num_adc_nids = preset->num_adc_nids;
 876         spec->adc_nids = preset->adc_nids;
 877         spec->capsrc_nids = preset->capsrc_nids;
 878         spec->dig_in_nid = preset->dig_in_nid;
 879
 880         spec->unsol_event = preset->unsol_event;
 881         spec->init_hook = preset->init_hook;
 882 #ifdef CONFIG_SND_HDA_POWER_SAVE
 883         spec->loopback.amplist = preset->loopbacks;
 884 #endif
 885 }
 886
 887 /* Enable GPIO mask and set output */
 888 static struct hda_verb alc_gpio1_init_verbs[] = {
 889         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 890         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 891         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 892         { }
 893 };
 894
 895 static struct hda_verb alc_gpio2_init_verbs[] = {
 896         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 897         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 898         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 899         { }
 900 };
 901
 902 static struct hda_verb alc_gpio3_init_verbs[] = {
 903         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 904         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 905         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 906         { }
 907 };
 908
 909 /*
 910  * Fix hardware PLL issue
 911  * On some codecs, the analog PLL gating control must be off while
 912  * the default value is 1.
 913  */
 914 static void alc_fix_pll(struct hda_codec *codec)
 915 {
 916         struct alc_spec *spec = codec->spec;
 917         unsigned int val;
 918
 919         if (!spec->pll_nid)
 920                 return;
 921         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 922                             spec->pll_coef_idx);
 923         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 924                                  AC_VERB_GET_PROC_COEF, 0);
 925         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 926                             spec->pll_coef_idx);
 927         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 928                             val & ~(1 << spec->pll_coef_bit));
 929 }
 930
 931 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 932                              unsigned int coef_idx, unsigned int coef_bit)
 933 {
 934         struct alc_spec *spec = codec->spec;
 935         spec->pll_nid = nid;
 936         spec->pll_coef_idx = coef_idx;
 937         spec->pll_coef_bit = coef_bit;
 938         alc_fix_pll(codec);
 939 }
 940
 941 static void alc_automute_pin(struct hda_codec *codec)
 942 {
 943         struct alc_spec *spec = codec->spec;
 944         unsigned int present, pincap;
 945         unsigned int nid = spec->autocfg.hp_pins[0];
 946         int i;
 947
 948         pincap = snd_hda_query_pin_caps(codec, nid);
 949         if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
 950                 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 951         present = snd_hda_codec_read(codec, nid, 0,
 952                                      AC_VERB_GET_PIN_SENSE, 0);
 953         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 954         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 955                 nid = spec->autocfg.speaker_pins[i];
 956                 if (!nid)
 957                         break;
 958                 snd_hda_codec_write(codec, nid, 0,
 959                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 960                                     spec->jack_present ? 0 : PIN_OUT);
 961         }
 962 }
 963
 964 #if 0 /* it's broken in some cases -- temporarily disabled */
 965 static void alc_mic_automute(struct hda_codec *codec)
 966 {
 967         struct alc_spec *spec = codec->spec;
 968         unsigned int present;
 969         unsigned int mic_nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
 970         unsigned int fmic_nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
 971         unsigned int mix_nid = spec->capsrc_nids[0];
 972         unsigned int capsrc_idx_mic, capsrc_idx_fmic;
 973
 974         capsrc_idx_mic = mic_nid - 0x18;
 975         capsrc_idx_fmic = fmic_nid - 0x18;
 976         present = snd_hda_codec_read(codec, mic_nid, 0,
 977                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
 978         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 979                     0x7000 | (capsrc_idx_mic << 8) | (present ? 0 : 0x80));
 980         snd_hda_codec_write(codec, mix_nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
 981                     0x7000 | (capsrc_idx_fmic << 8) | (present ? 0x80 : 0));
 982         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, capsrc_idx_fmic,
 983                          HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
 984 }
 985 #else
 986 #define alc_mic_automute(codec) do {} while(0) /* NOP */
 987 #endif /* disabled */
 988
 989 /* unsolicited event for HP jack sensing */
 990 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
 991 {
 992         if (codec->vendor_id == 0x10ec0880)
 993                 res >>= 28;
 994         else
 995                 res >>= 26;
 996         switch (res) {
 997         case ALC880_HP_EVENT:
 998                 alc_automute_pin(codec);
 999                 break;
1000         case ALC880_MIC_EVENT:
1001                 alc_mic_automute(codec);
1002                 break;
1003         }
1004 }
1005
1006 static void alc_inithook(struct hda_codec *codec)
1007 {
1008         alc_automute_pin(codec);
1009         alc_mic_automute(codec);
1010 }
1011
1012 /* additional initialization for ALC888 variants */
1013 static void alc888_coef_init(struct hda_codec *codec)
1014 {
1015         unsigned int tmp;
1016
1017         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1018         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1019         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1020         if ((tmp & 0xf0) == 0x20)
1021                 /* alc888S-VC */
1022                 snd_hda_codec_read(codec, 0x20, 0,
1023                                    AC_VERB_SET_PROC_COEF, 0x830);
1024          else
1025                  /* alc888-VB */
1026                  snd_hda_codec_read(codec, 0x20, 0,
1027                                     AC_VERB_SET_PROC_COEF, 0x3030);
1028 }
1029
1030 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1031 {
1032         unsigned int tmp;
1033
1034         switch (type) {
1035         case ALC_INIT_GPIO1:
1036                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1037                 break;
1038         case ALC_INIT_GPIO2:
1039                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1040                 break;
1041         case ALC_INIT_GPIO3:
1042                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1043                 break;
1044         case ALC_INIT_DEFAULT:
1045                 switch (codec->vendor_id) {
1046                 case 0x10ec0260:
1047                         snd_hda_codec_write(codec, 0x0f, 0,
1048                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1049                         snd_hda_codec_write(codec, 0x10, 0,
1050                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1051                         break;
1052                 case 0x10ec0262:
1053                 case 0x10ec0267:
1054                 case 0x10ec0268:
1055                 case 0x10ec0269:
1056                 case 0x10ec0272:
1057                 case 0x10ec0660:
1058                 case 0x10ec0662:
1059                 case 0x10ec0663:
1060                 case 0x10ec0862:
1061                 case 0x10ec0889:
1062                         snd_hda_codec_write(codec, 0x14, 0,
1063                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1064                         snd_hda_codec_write(codec, 0x15, 0,
1065                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1066                         break;
1067                 }
1068                 switch (codec->vendor_id) {
1069                 case 0x10ec0260:
1070                         snd_hda_codec_write(codec, 0x1a, 0,
1071                                             AC_VERB_SET_COEF_INDEX, 7);
1072                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1073                                                  AC_VERB_GET_PROC_COEF, 0);
1074                         snd_hda_codec_write(codec, 0x1a, 0,
1075                                             AC_VERB_SET_COEF_INDEX, 7);
1076                         snd_hda_codec_write(codec, 0x1a, 0,
1077                                             AC_VERB_SET_PROC_COEF,
1078                                             tmp | 0x2010);
1079                         break;
1080                 case 0x10ec0262:
1081                 case 0x10ec0880:
1082                 case 0x10ec0882:
1083                 case 0x10ec0883:
1084                 case 0x10ec0885:
1085                 case 0x10ec0887:
1086                 case 0x10ec0889:
1087                         snd_hda_codec_write(codec, 0x20, 0,
1088                                             AC_VERB_SET_COEF_INDEX, 7);
1089                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1090                                                  AC_VERB_GET_PROC_COEF, 0);
1091                         snd_hda_codec_write(codec, 0x20, 0,
1092                                             AC_VERB_SET_COEF_INDEX, 7);
1093                         snd_hda_codec_write(codec, 0x20, 0,
1094                                             AC_VERB_SET_PROC_COEF,
1095                                             tmp | 0x2010);
1096                         break;
1097                 case 0x10ec0888:
1098                         alc888_coef_init(codec);
1099                         break;
1100                 case 0x10ec0267:
1101                 case 0x10ec0268:
1102                         snd_hda_codec_write(codec, 0x20, 0,
1103                                             AC_VERB_SET_COEF_INDEX, 7);
1104                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1105                                                  AC_VERB_GET_PROC_COEF, 0);
1106                         snd_hda_codec_write(codec, 0x20, 0,
1107                                             AC_VERB_SET_COEF_INDEX, 7);
1108                         snd_hda_codec_write(codec, 0x20, 0,
1109                                             AC_VERB_SET_PROC_COEF,
1110                                             tmp | 0x3000);
1111                         break;
1112                 }
1113                 break;
1114         }
1115 }
1116
1117 static void alc_init_auto_hp(struct hda_codec *codec)
1118 {
1119         struct alc_spec *spec = codec->spec;
1120
1121         if (!spec->autocfg.hp_pins[0])
1122                 return;
1123
1124         if (!spec->autocfg.speaker_pins[0]) {
1125                 if (spec->autocfg.line_out_pins[0] &&
1126                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1127                         spec->autocfg.speaker_pins[0] =
1128                                 spec->autocfg.line_out_pins[0];
1129                 else
1130                         return;
1131         }
1132
1133         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1134                     spec->autocfg.hp_pins[0]);
1135         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1136                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1137                                   AC_USRSP_EN | ALC880_HP_EVENT);
1138         spec->unsol_event = alc_sku_unsol_event;
1139 }
1140
1141 /* check subsystem ID and set up device-specific initialization;
1142  * return 1 if initialized, 0 if invalid SSID
1143  */
1144 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1145  *      31 ~ 16 :       Manufacture ID
1146  *      15 ~ 8  :       SKU ID
1147  *      7  ~ 0  :       Assembly ID
1148  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1149  */
1150 static int alc_subsystem_id(struct hda_codec *codec,
1151                             hda_nid_t porta, hda_nid_t porte,
1152                             hda_nid_t portd)
1153 {
1154         unsigned int ass, tmp, i;
1155         unsigned nid;
1156         struct alc_spec *spec = codec->spec;
1157
1158         ass = codec->subsystem_id & 0xffff;
1159         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1160                 goto do_sku;
1161
1162         /* invalid SSID, check the special NID pin defcfg instead */
1163         /*
1164          * 31~30        : port connectivity
1165          * 29~21        : reserve
1166          * 20           : PCBEEP input
1167          * 19~16        : Check sum (15:1)
1168          * 15~1         : Custom
1169          * 0            : override
1170         */
1171         nid = 0x1d;
1172         if (codec->vendor_id == 0x10ec0260)
1173                 nid = 0x17;
1174         ass = snd_hda_codec_get_pincfg(codec, nid);
1175         snd_printd("realtek: No valid SSID, "
1176                    "checking pincfg 0x%08x for NID 0x%x\n",
1177                    ass, nid);
1178         if (!(ass & 1) && !(ass & 0x100000))
1179                 return 0;
1180         if ((ass >> 30) != 1)   /* no physical connection */
1181                 return 0;
1182
1183         /* check sum */
1184         tmp = 0;
1185         for (i = 1; i < 16; i++) {
1186                 if ((ass >> i) & 1)
1187                         tmp++;
1188         }
1189         if (((ass >> 16) & 0xf) != tmp)
1190                 return 0;
1191 do_sku:
1192         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1193                    ass & 0xffff, codec->vendor_id);
1194         /*
1195          * 0 : override
1196          * 1 :  Swap Jack
1197          * 2 : 0 --> Desktop, 1 --> Laptop
1198          * 3~5 : External Amplifier control
1199          * 7~6 : Reserved
1200         */
1201         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1202         switch (tmp) {
1203         case 1:
1204                 spec->init_amp = ALC_INIT_GPIO1;
1205                 break;
1206         case 3:
1207                 spec->init_amp = ALC_INIT_GPIO2;
1208                 break;
1209         case 7:
1210                 spec->init_amp = ALC_INIT_GPIO3;
1211                 break;
1212         case 5:
1213                 spec->init_amp = ALC_INIT_DEFAULT;
1214                 break;
1215         }
1216
1217         /* is laptop or Desktop and enable the function "Mute internal speaker
1218          * when the external headphone out jack is plugged"
1219          */
1220         if (!(ass & 0x8000))
1221                 return 1;
1222         /*
1223          * 10~8 : Jack location
1224          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1225          * 14~13: Resvered
1226          * 15   : 1 --> enable the function "Mute internal speaker
1227          *              when the external headphone out jack is plugged"
1228          */
1229         if (!spec->autocfg.hp_pins[0]) {
1230                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1231                 if (tmp == 0)
1232                         spec->autocfg.hp_pins[0] = porta;
1233                 else if (tmp == 1)
1234                         spec->autocfg.hp_pins[0] = porte;
1235                 else if (tmp == 2)
1236                         spec->autocfg.hp_pins[0] = portd;
1237                 else
1238                         return 1;
1239         }
1240
1241         alc_init_auto_hp(codec);
1242         return 1;
1243 }
1244
1245 static void alc_ssid_check(struct hda_codec *codec,
1246                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1247 {
1248         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1249                 struct alc_spec *spec = codec->spec;
1250                 snd_printd("realtek: "
1251                            "Enable default setup for auto mode as fallback\n");
1252                 spec->init_amp = ALC_INIT_DEFAULT;
1253                 alc_init_auto_hp(codec);
1254         }
1255 }
1256
1257 /*
1258  * Fix-up pin default configurations
1259  */
1260
1261 struct alc_pincfg {
1262         hda_nid_t nid;
1263         u32 val;
1264 };
1265
1266 static void alc_fix_pincfg(struct hda_codec *codec,
1267                            const struct snd_pci_quirk *quirk,
1268                            const struct alc_pincfg **pinfix)
1269 {
1270         const struct alc_pincfg *cfg;
1271
1272         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1273         if (!quirk)
1274                 return;
1275
1276         cfg = pinfix[quirk->value];
1277         for (; cfg->nid; cfg++)
1278                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1279 }
1280
1281 /*
1282  * ALC888
1283  */
1284
1285 /*
1286  * 2ch mode
1287  */
1288 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1289 /* Mic-in jack as mic in */
1290         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1291         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1292 /* Line-in jack as Line in */
1293         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1294         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1295 /* Line-Out as Front */
1296         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1297         { } /* end */
1298 };
1299
1300 /*
1301  * 4ch mode
1302  */
1303 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1304 /* Mic-in jack as mic in */
1305         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1306         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1307 /* Line-in jack as Surround */
1308         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1309         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1310 /* Line-Out as Front */
1311         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1312         { } /* end */
1313 };
1314
1315 /*
1316  * 6ch mode
1317  */
1318 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1319 /* Mic-in jack as CLFE */
1320         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1321         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1322 /* Line-in jack as Surround */
1323         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1324         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1325 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1326         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1327         { } /* end */
1328 };
1329
1330 /*
1331  * 8ch mode
1332  */
1333 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1334 /* Mic-in jack as CLFE */
1335         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1336         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1337 /* Line-in jack as Surround */
1338         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1339         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1340 /* Line-Out as Side */
1341         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1342         { } /* end */
1343 };
1344
1345 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1346         { 2, alc888_4ST_ch2_intel_init },
1347         { 4, alc888_4ST_ch4_intel_init },
1348         { 6, alc888_4ST_ch6_intel_init },
1349         { 8, alc888_4ST_ch8_intel_init },
1350 };
1351
1352 /*
1353  * ALC888 Fujitsu Siemens Amillo xa3530
1354  */
1355
1356 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1357 /* Front Mic: set to PIN_IN (empty by default) */
1358         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1359 /* Connect Internal HP to Front */
1360         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1361         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1362         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1363 /* Connect Bass HP to Front */
1364         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1365         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1366         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1367 /* Connect Line-Out side jack (SPDIF) to Side */
1368         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1369         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1370         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1371 /* Connect Mic jack to CLFE */
1372         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1373         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1374         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1375 /* Connect Line-in jack to Surround */
1376         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1377         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1378         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1379 /* Connect HP out jack to Front */
1380         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1381         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1382         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1383 /* Enable unsolicited event for HP jack and Line-out jack */
1384         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1385         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1386         {}
1387 };
1388
1389 static void alc_automute_amp(struct hda_codec *codec)
1390 {
1391         struct alc_spec *spec = codec->spec;
1392         unsigned int val, mute, pincap;
1393         hda_nid_t nid;
1394         int i;
1395
1396         spec->jack_present = 0;
1397         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1398                 nid = spec->autocfg.hp_pins[i];
1399                 if (!nid)
1400                         break;
1401                 pincap = snd_hda_query_pin_caps(codec, nid);
1402                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1403                         snd_hda_codec_read(codec, nid, 0,
1404                                            AC_VERB_SET_PIN_SENSE, 0);
1405                 val = snd_hda_codec_read(codec, nid, 0,
1406                                          AC_VERB_GET_PIN_SENSE, 0);
1407                 if (val & AC_PINSENSE_PRESENCE) {
1408                         spec->jack_present = 1;
1409                         break;
1410                 }
1411         }
1412
1413         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1414         /* Toggle internal speakers muting */
1415         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1416                 nid = spec->autocfg.speaker_pins[i];
1417                 if (!nid)
1418                         break;
1419                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1420                                          HDA_AMP_MUTE, mute);
1421         }
1422 }
1423
1424 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1425                                          unsigned int res)
1426 {
1427         if (codec->vendor_id == 0x10ec0880)
1428                 res >>= 28;
1429         else
1430                 res >>= 26;
1431         if (res == ALC880_HP_EVENT)
1432                 alc_automute_amp(codec);
1433 }
1434
1435 static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
1436 {
1437         struct alc_spec *spec = codec->spec;
1438
1439         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1440         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1441         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1442         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1443         alc_automute_amp(codec);
1444 }
1445
1446 /*
1447  * ALC888 Acer Aspire 4930G model
1448  */
1449
1450 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1451 /* Front Mic: set to PIN_IN (empty by default) */
1452         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1453 /* Unselect Front Mic by default in input mixer 3 */
1454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1455 /* Enable unsolicited event for HP jack */
1456         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1457 /* Connect Internal HP to front */
1458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1459         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1460         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1461 /* Connect HP out to front */
1462         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1463         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1464         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1465         { }
1466 };
1467
1468 /*
1469  * ALC888 Acer Aspire 6530G model
1470  */
1471
1472 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1473 /* Bias voltage on for external mic port */
1474         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1475 /* Front Mic: set to PIN_IN (empty by default) */
1476         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1477 /* Unselect Front Mic by default in input mixer 3 */
1478         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1479 /* Enable unsolicited event for HP jack */
1480         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1481 /* Enable speaker output */
1482         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1484 /* Enable headphone output */
1485         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1486         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1487         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1488         { }
1489 };
1490
1491 /*
1492  * ALC889 Acer Aspire 8930G model
1493  */
1494
1495 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1496 /* Front Mic: set to PIN_IN (empty by default) */
1497         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1498 /* Unselect Front Mic by default in input mixer 3 */
1499         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1500 /* Enable unsolicited event for HP jack */
1501         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1502 /* Connect Internal Front to Front */
1503         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1504         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1505         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1506 /* Connect Internal Rear to Rear */
1507         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1508         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1509         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1510 /* Connect Internal CLFE to CLFE */
1511         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1512         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1513         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1514 /* Connect HP out to Front */
1515         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1516         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1517         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1518 /* Enable all DACs */
1519 /*  DAC DISABLE/MUTE 1? */
1520 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1521         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1522         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1523 /*  DAC DISABLE/MUTE 2? */
1524 /*  some bit here disables the other DACs. Init=0x4900 */
1525         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1526         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1527 /* Enable amplifiers */
1528         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1529         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1530 /* DMIC fix
1531  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1532  * which makes the stereo useless. However, either the mic or the ALC889
1533  * makes the signal become a difference/sum signal instead of standard
1534  * stereo, which is annoying. So instead we flip this bit which makes the
1535  * codec replicate the sum signal to both channels, turning it into a
1536  * normal mono mic.
1537  */
1538 /*  DMIC_CONTROL? Init value = 0x0001 */
1539         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1540         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1541         { }
1542 };
1543
1544 static struct hda_input_mux alc888_2_capture_sources[2] = {
1545         /* Front mic only available on one ADC */
1546         {
1547                 .num_items = 4,
1548                 .items = {
1549                         { "Mic", 0x0 },
1550                         { "Line", 0x2 },
1551                         { "CD", 0x4 },
1552                         { "Front Mic", 0xb },
1553                 },
1554         },
1555         {
1556                 .num_items = 3,
1557                 .items = {
1558                         { "Mic", 0x0 },
1559                         { "Line", 0x2 },
1560                         { "CD", 0x4 },
1561                 },
1562         }
1563 };
1564
1565 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1566         /* Interal mic only available on one ADC */
1567         {
1568                 .num_items = 5,
1569                 .items = {
1570                         { "Ext Mic", 0x0 },
1571                         { "Line In", 0x2 },
1572                         { "CD", 0x4 },
1573                         { "Input Mix", 0xa },
1574                         { "Int Mic", 0xb },
1575                 },
1576         },
1577         {
1578                 .num_items = 4,
1579                 .items = {
1580                         { "Ext Mic", 0x0 },
1581                         { "Line In", 0x2 },
1582                         { "CD", 0x4 },
1583                         { "Input Mix", 0xa },
1584                 },
1585         }
1586 };
1587
1588 static struct hda_input_mux alc889_capture_sources[3] = {
1589         /* Digital mic only available on first "ADC" */
1590         {
1591                 .num_items = 5,
1592                 .items = {
1593                         { "Mic", 0x0 },
1594                         { "Line", 0x2 },
1595                         { "CD", 0x4 },
1596                         { "Front Mic", 0xb },
1597                         { "Input Mix", 0xa },
1598                 },
1599         },
1600         {
1601                 .num_items = 4,
1602                 .items = {
1603                         { "Mic", 0x0 },
1604                         { "Line", 0x2 },
1605                         { "CD", 0x4 },
1606                         { "Input Mix", 0xa },
1607                 },
1608         },
1609         {
1610                 .num_items = 4,
1611                 .items = {
1612                         { "Mic", 0x0 },
1613                         { "Line", 0x2 },
1614                         { "CD", 0x4 },
1615                         { "Input Mix", 0xa },
1616                 },
1617         }
1618 };
1619
1620 static struct snd_kcontrol_new alc888_base_mixer[] = {
1621         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1622         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1623         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1624         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1625         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1626                 HDA_OUTPUT),
1627         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1628         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1629         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1630         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1631         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1632         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1633         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1634         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1635         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1636         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1637         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1638         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1639         { } /* end */
1640 };
1641
1642 static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *codec)
1643 {
1644         struct alc_spec *spec = codec->spec;
1645
1646         spec->autocfg.hp_pins[0] = 0x15;
1647         spec->autocfg.speaker_pins[0] = 0x14;
1648         alc_automute_amp(codec);
1649 }
1650
1651 static void alc888_acer_aspire_6530g_init_hook(struct hda_codec *codec)
1652 {
1653         struct alc_spec *spec = codec->spec;
1654
1655         spec->autocfg.hp_pins[0] = 0x15;
1656         spec->autocfg.speaker_pins[0] = 0x14;
1657         spec->autocfg.speaker_pins[1] = 0x16;
1658         spec->autocfg.speaker_pins[2] = 0x17;
1659         alc_automute_amp(codec);
1660 }
1661
1662 static void alc889_acer_aspire_8930g_init_hook(struct hda_codec *codec)
1663 {
1664         struct alc_spec *spec = codec->spec;
1665
1666         spec->autocfg.hp_pins[0] = 0x15;
1667         spec->autocfg.speaker_pins[0] = 0x14;
1668         spec->autocfg.speaker_pins[1] = 0x16;
1669         spec->autocfg.speaker_pins[2] = 0x1b;
1670         alc_automute_amp(codec);
1671 }
1672
1673 /*
1674  * ALC880 3-stack model
1675  *
1676  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1677  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1678  *                 F-Mic = 0x1b, HP = 0x19
1679  */
1680
1681 static hda_nid_t alc880_dac_nids[4] = {
1682         /* front, rear, clfe, rear_surr */
1683         0x02, 0x05, 0x04, 0x03
1684 };
1685
1686 static hda_nid_t alc880_adc_nids[3] = {
1687         /* ADC0-2 */
1688         0x07, 0x08, 0x09,
1689 };
1690
1691 /* The datasheet says the node 0x07 is connected from inputs,
1692  * but it shows zero connection in the real implementation on some devices.
1693  * Note: this is a 915GAV bug, fixed on 915GLV
1694  */
1695 static hda_nid_t alc880_adc_nids_alt[2] = {
1696         /* ADC1-2 */
1697         0x08, 0x09,
1698 };
1699
1700 #define ALC880_DIGOUT_NID       0x06
1701 #define ALC880_DIGIN_NID        0x0a
1702
1703 static struct hda_input_mux alc880_capture_source = {
1704         .num_items = 4,
1705         .items = {
1706                 { "Mic", 0x0 },
1707                 { "Front Mic", 0x3 },
1708                 { "Line", 0x2 },
1709                 { "CD", 0x4 },
1710         },
1711 };
1712
1713 /* channel source setting (2/6 channel selection for 3-stack) */
1714 /* 2ch mode */
1715 static struct hda_verb alc880_threestack_ch2_init[] = {
1716         /* set line-in to input, mute it */
1717         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1718         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1719         /* set mic-in to input vref 80%, mute it */
1720         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1721         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1722         { } /* end */
1723 };
1724
1725 /* 6ch mode */
1726 static struct hda_verb alc880_threestack_ch6_init[] = {
1727         /* set line-in to output, unmute it */
1728         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1729         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1730         /* set mic-in to output, unmute it */
1731         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1732         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1733         { } /* end */
1734 };
1735
1736 static struct hda_channel_mode alc880_threestack_modes[2] = {
1737         { 2, alc880_threestack_ch2_init },
1738         { 6, alc880_threestack_ch6_init },
1739 };
1740
1741 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1742         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1743         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1744         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1745         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1746         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1747         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1748         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1749         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1750         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1751         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1752         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1753         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1754         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1755         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1756         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1757         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1758         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1759         {
1760                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1761                 .name = "Channel Mode",
1762                 .info = alc_ch_mode_info,
1763                 .get = alc_ch_mode_get,
1764                 .put = alc_ch_mode_put,
1765         },
1766         { } /* end */
1767 };
1768
1769 /* capture mixer elements */
1770 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1771                             struct snd_ctl_elem_info *uinfo)
1772 {
1773         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1774         struct alc_spec *spec = codec->spec;
1775         int err;
1776
1777         mutex_lock(&codec->control_mutex);
1778         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1779                                                       HDA_INPUT);
1780         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1781         mutex_unlock(&codec->control_mutex);
1782         return err;
1783 }
1784
1785 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1786                            unsigned int size, unsigned int __user *tlv)
1787 {
1788         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1789         struct alc_spec *spec = codec->spec;
1790         int err;
1791
1792         mutex_lock(&codec->control_mutex);
1793         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1794                                                       HDA_INPUT);
1795         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1796         mutex_unlock(&codec->control_mutex);
1797         return err;
1798 }
1799
1800 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1801                              struct snd_ctl_elem_value *ucontrol);
1802
1803 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1804                                  struct snd_ctl_elem_value *ucontrol,
1805                                  getput_call_t func)
1806 {
1807         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1808         struct alc_spec *spec = codec->spec;
1809         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1810         int err;
1811
1812         mutex_lock(&codec->control_mutex);
1813         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1814                                                       3, 0, HDA_INPUT);
1815         err = func(kcontrol, ucontrol);
1816         mutex_unlock(&codec->control_mutex);
1817         return err;
1818 }
1819
1820 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1821                            struct snd_ctl_elem_value *ucontrol)
1822 {
1823         return alc_cap_getput_caller(kcontrol, ucontrol,
1824                                      snd_hda_mixer_amp_volume_get);
1825 }
1826
1827 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1828                            struct snd_ctl_elem_value *ucontrol)
1829 {
1830         return alc_cap_getput_caller(kcontrol, ucontrol,
1831                                      snd_hda_mixer_amp_volume_put);
1832 }
1833
1834 /* capture mixer elements */
1835 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1836
1837 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1838                           struct snd_ctl_elem_value *ucontrol)
1839 {
1840         return alc_cap_getput_caller(kcontrol, ucontrol,
1841                                      snd_hda_mixer_amp_switch_get);
1842 }
1843
1844 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1845                           struct snd_ctl_elem_value *ucontrol)
1846 {
1847         return alc_cap_getput_caller(kcontrol, ucontrol,
1848                                      snd_hda_mixer_amp_switch_put);
1849 }
1850
1851 #define _DEFINE_CAPMIX(num) \
1852         { \
1853                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1854                 .name = "Capture Switch", \
1855                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1856                 .count = num, \
1857                 .info = alc_cap_sw_info, \
1858                 .get = alc_cap_sw_get, \
1859                 .put = alc_cap_sw_put, \
1860         }, \
1861         { \
1862                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1863                 .name = "Capture Volume", \
1864                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1865                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1866                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
1867                 .count = num, \
1868                 .info = alc_cap_vol_info, \
1869                 .get = alc_cap_vol_get, \
1870                 .put = alc_cap_vol_put, \
1871                 .tlv = { .c = alc_cap_vol_tlv }, \
1872         }
1873
1874 #define _DEFINE_CAPSRC(num) \
1875         { \
1876                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1877                 /* .name = "Capture Source", */ \
1878                 .name = "Input Source", \
1879                 .count = num, \
1880                 .info = alc_mux_enum_info, \
1881                 .get = alc_mux_enum_get, \
1882                 .put = alc_mux_enum_put, \
1883         }
1884
1885 #define DEFINE_CAPMIX(num) \
1886 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
1887         _DEFINE_CAPMIX(num),                                  \
1888         _DEFINE_CAPSRC(num),                                  \
1889         { } /* end */                                         \
1890 }
1891
1892 #define DEFINE_CAPMIX_NOSRC(num) \
1893 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
1894         _DEFINE_CAPMIX(num),                                        \
1895         { } /* end */                                               \
1896 }
1897
1898 /* up to three ADCs */
1899 DEFINE_CAPMIX(1);
1900 DEFINE_CAPMIX(2);
1901 DEFINE_CAPMIX(3);
1902 DEFINE_CAPMIX_NOSRC(1);
1903 DEFINE_CAPMIX_NOSRC(2);
1904 DEFINE_CAPMIX_NOSRC(3);
1905
1906 /*
1907  * ALC880 5-stack model
1908  *
1909  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
1910  *      Side = 0x02 (0xd)
1911  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
1912  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
1913  */
1914
1915 /* additional mixers to alc880_three_stack_mixer */
1916 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
1917         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1918         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
1919         { } /* end */
1920 };
1921
1922 /* channel source setting (6/8 channel selection for 5-stack) */
1923 /* 6ch mode */
1924 static struct hda_verb alc880_fivestack_ch6_init[] = {
1925         /* set line-in to input, mute it */
1926         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1927         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1928         { } /* end */
1929 };
1930
1931 /* 8ch mode */
1932 static struct hda_verb alc880_fivestack_ch8_init[] = {
1933         /* set line-in to output, unmute it */
1934         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1935         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1936         { } /* end */
1937 };
1938
1939 static struct hda_channel_mode alc880_fivestack_modes[2] = {
1940         { 6, alc880_fivestack_ch6_init },
1941         { 8, alc880_fivestack_ch8_init },
1942 };
1943
1944
1945 /*
1946  * ALC880 6-stack model
1947  *
1948  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
1949  *      Side = 0x05 (0x0f)
1950  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
1951  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
1952  */
1953
1954 static hda_nid_t alc880_6st_dac_nids[4] = {
1955         /* front, rear, clfe, rear_surr */
1956         0x02, 0x03, 0x04, 0x05
1957 };
1958
1959 static struct hda_input_mux alc880_6stack_capture_source = {
1960         .num_items = 4,
1961         .items = {
1962                 { "Mic", 0x0 },
1963                 { "Front Mic", 0x1 },
1964                 { "Line", 0x2 },
1965                 { "CD", 0x4 },
1966         },
1967 };
1968
1969 /* fixed 8-channels */
1970 static struct hda_channel_mode alc880_sixstack_modes[1] = {
1971         { 8, NULL },
1972 };
1973
1974 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
1975         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1976         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1977         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1978         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1979         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1980         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1981         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1982         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1983         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1984         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1985         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1986         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1987         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1988         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1989         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1990         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1991         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
1992         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
1993         {
1994                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1995                 .name = "Channel Mode",
1996                 .info = alc_ch_mode_info,
1997                 .get = alc_ch_mode_get,
1998                 .put = alc_ch_mode_put,
1999         },
2000         { } /* end */
2001 };
2002
2003
2004 /*
2005  * ALC880 W810 model
2006  *
2007  * W810 has rear IO for:
2008  * Front (DAC 02)
2009  * Surround (DAC 03)
2010  * Center/LFE (DAC 04)
2011  * Digital out (06)
2012  *
2013  * The system also has a pair of internal speakers, and a headphone jack.
2014  * These are both connected to Line2 on the codec, hence to DAC 02.
2015  *
2016  * There is a variable resistor to control the speaker or headphone
2017  * volume. This is a hardware-only device without a software API.
2018  *
2019  * Plugging headphones in will disable the internal speakers. This is
2020  * implemented in hardware, not via the driver using jack sense. In
2021  * a similar fashion, plugging into the rear socket marked "front" will
2022  * disable both the speakers and headphones.
2023  *
2024  * For input, there's a microphone jack, and an "audio in" jack.
2025  * These may not do anything useful with this driver yet, because I
2026  * haven't setup any initialization verbs for these yet...
2027  */
2028
2029 static hda_nid_t alc880_w810_dac_nids[3] = {
2030         /* front, rear/surround, clfe */
2031         0x02, 0x03, 0x04
2032 };
2033
2034 /* fixed 6 channels */
2035 static struct hda_channel_mode alc880_w810_modes[1] = {
2036         { 6, NULL }
2037 };
2038
2039 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2040 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2041         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2042         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2043         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2044         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2045         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2046         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2047         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2048         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2049         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2050         { } /* end */
2051 };
2052
2053
2054 /*
2055  * Z710V model
2056  *
2057  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2058  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2059  *                 Line = 0x1a
2060  */
2061
2062 static hda_nid_t alc880_z71v_dac_nids[1] = {
2063         0x02
2064 };
2065 #define ALC880_Z71V_HP_DAC      0x03
2066
2067 /* fixed 2 channels */
2068 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2069         { 2, NULL }
2070 };
2071
2072 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2073         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2074         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2075         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2076         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2077         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2078         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2079         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2080         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2081         { } /* end */
2082 };
2083
2084
2085 /*
2086  * ALC880 F1734 model
2087  *
2088  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2089  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2090  */
2091
2092 static hda_nid_t alc880_f1734_dac_nids[1] = {
2093         0x03
2094 };
2095 #define ALC880_F1734_HP_DAC     0x02
2096
2097 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2098         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2099         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2100         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2101         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2102         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2103         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2104         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2105         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2106         { } /* end */
2107 };
2108
2109 static struct hda_input_mux alc880_f1734_capture_source = {
2110         .num_items = 2,
2111         .items = {
2112                 { "Mic", 0x1 },
2113                 { "CD", 0x4 },
2114         },
2115 };
2116
2117
2118 /*
2119  * ALC880 ASUS model
2120  *
2121  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2122  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2123  *  Mic = 0x18, Line = 0x1a
2124  */
2125
2126 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2127 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2128
2129 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2130         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2131         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2132         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2133         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2134         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2135         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2136         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2137         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2138         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2139         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2140         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2141         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2142         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2143         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2144         {
2145                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2146                 .name = "Channel Mode",
2147                 .info = alc_ch_mode_info,
2148                 .get = alc_ch_mode_get,
2149                 .put = alc_ch_mode_put,
2150         },
2151         { } /* end */
2152 };
2153
2154 /*
2155  * ALC880 ASUS W1V model
2156  *
2157  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2158  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2159  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2160  */
2161
2162 /* additional mixers to alc880_asus_mixer */
2163 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2164         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2165         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2166         { } /* end */
2167 };
2168
2169 /* TCL S700 */
2170 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2171         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2172         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2173         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2174         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2175         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2176         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2177         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2178         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2179         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2180         { } /* end */
2181 };
2182
2183 /* Uniwill */
2184 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2185         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2186         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2187         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2188         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2189         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2190         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2191         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2192         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2193         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2194         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2195         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2196         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2197         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2198         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2199         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2200         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2201         {
2202                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2203                 .name = "Channel Mode",
2204                 .info = alc_ch_mode_info,
2205                 .get = alc_ch_mode_get,
2206                 .put = alc_ch_mode_put,
2207         },
2208         { } /* end */
2209 };
2210
2211 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2212         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2213         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2214         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2215         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2216         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2217         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2218         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2219         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2220         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2221         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2222         { } /* end */
2223 };
2224
2225 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2226         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2227         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2228         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2229         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2230         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2231         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2232         { } /* end */
2233 };
2234
2235 /*
2236  * virtual master controls
2237  */
2238
2239 /*
2240  * slave controls for virtual master
2241  */
2242 static const char *alc_slave_vols[] = {
2243         "Front Playback Volume",
2244         "Surround Playback Volume",
2245         "Center Playback Volume",
2246         "LFE Playback Volume",
2247         "Side Playback Volume",
2248         "Headphone Playback Volume",
2249         "Speaker Playback Volume",
2250         "Mono Playback Volume",
2251         "Line-Out Playback Volume",
2252         "PCM Playback Volume",
2253         NULL,
2254 };
2255
2256 static const char *alc_slave_sws[] = {
2257         "Front Playback Switch",
2258         "Surround Playback Switch",
2259         "Center Playback Switch",
2260         "LFE Playback Switch",
2261         "Side Playback Switch",
2262         "Headphone Playback Switch",
2263         "Speaker Playback Switch",
2264         "Mono Playback Switch",
2265         "IEC958 Playback Switch",
2266         NULL,
2267 };
2268
2269 /*
2270  * build control elements
2271  */
2272
2273 static void alc_free_kctls(struct hda_codec *codec);
2274
2275 /* additional beep mixers; the actual parameters are overwritten at build */
2276 static struct snd_kcontrol_new alc_beep_mixer[] = {
2277         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2278         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2279         { } /* end */
2280 };
2281
2282 static int alc_build_controls(struct hda_codec *codec)
2283 {
2284         struct alc_spec *spec = codec->spec;
2285         int err;
2286         int i;
2287
2288         for (i = 0; i < spec->num_mixers; i++) {
2289                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2290                 if (err < 0)
2291                         return err;
2292         }
2293         if (spec->cap_mixer) {
2294                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2295                 if (err < 0)
2296                         return err;
2297         }
2298         if (spec->multiout.dig_out_nid) {
2299                 err = snd_hda_create_spdif_out_ctls(codec,
2300                                                     spec->multiout.dig_out_nid);
2301                 if (err < 0)
2302                         return err;
2303                 if (!spec->no_analog) {
2304                         err = snd_hda_create_spdif_share_sw(codec,
2305                                                             &spec->multiout);
2306                         if (err < 0)
2307                                 return err;
2308                         spec->multiout.share_spdif = 1;
2309                 }
2310         }
2311         if (spec->dig_in_nid) {
2312                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2313                 if (err < 0)
2314                         return err;
2315         }
2316
2317         /* create beep controls if needed */
2318         if (spec->beep_amp) {
2319                 struct snd_kcontrol_new *knew;
2320                 for (knew = alc_beep_mixer; knew->name; knew++) {
2321                         struct snd_kcontrol *kctl;
2322                         kctl = snd_ctl_new1(knew, codec);
2323                         if (!kctl)
2324                                 return -ENOMEM;
2325                         kctl->private_value = spec->beep_amp;
2326                         err = snd_hda_ctl_add(codec, kctl);
2327                         if (err < 0)
2328                                 return err;
2329                 }
2330         }
2331
2332         /* if we have no master control, let's create it */
2333         if (!spec->no_analog &&
2334             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2335                 unsigned int vmaster_tlv[4];
2336                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2337                                         HDA_OUTPUT, vmaster_tlv);
2338                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2339                                           vmaster_tlv, alc_slave_vols);
2340                 if (err < 0)
2341                         return err;
2342         }
2343         if (!spec->no_analog &&
2344             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2345                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2346                                           NULL, alc_slave_sws);
2347                 if (err < 0)
2348                         return err;
2349         }
2350
2351         alc_free_kctls(codec); /* no longer needed */
2352         return 0;
2353 }
2354
2355
2356 /*
2357  * initialize the codec volumes, etc
2358  */
2359
2360 /*
2361  * generic initialization of ADC, input mixers and output mixers
2362  */
2363 static struct hda_verb alc880_volume_init_verbs[] = {
2364         /*
2365          * Unmute ADC0-2 and set the default input to mic-in
2366          */
2367         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2368         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2369         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2370         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2371         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2372         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2373
2374         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2375          * mixer widget
2376          * Note: PASD motherboards uses the Line In 2 as the input for front
2377          * panel mic (mic 2)
2378          */
2379         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2380         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2381         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2382         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2383         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2384         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2385         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2386         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2387
2388         /*
2389          * Set up output mixers (0x0c - 0x0f)
2390          */
2391         /* set vol=0 to output mixers */
2392         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2393         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2394         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2395         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2396         /* set up input amps for analog loopback */
2397         /* Amp Indices: DAC = 0, mixer = 1 */
2398         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2399         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2400         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2401         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2402         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2403         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2404         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2405         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2406
2407         { }
2408 };
2409
2410 /*
2411  * 3-stack pin configuration:
2412  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2413  */
2414 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2415         /*
2416          * preset connection lists of input pins
2417          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2418          */
2419         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2420         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2421         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2422
2423         /*
2424          * Set pin mode and muting
2425          */
2426         /* set front pin widgets 0x14 for output */
2427         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2428         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2429         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2431         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2432         /* Mic2 (as headphone out) for HP output */
2433         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2434         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2435         /* Line In pin widget for input */
2436         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2437         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2438         /* Line2 (as front mic) pin widget for input and vref at 80% */
2439         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2440         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2441         /* CD pin widget for input */
2442         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2443
2444         { }
2445 };
2446
2447 /*
2448  * 5-stack pin configuration:
2449  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2450  * line-in/side = 0x1a, f-mic = 0x1b
2451  */
2452 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2453         /*
2454          * preset connection lists of input pins
2455          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2456          */
2457         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2458         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2459
2460         /*
2461          * Set pin mode and muting
2462          */
2463         /* set pin widgets 0x14-0x17 for output */
2464         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2465         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2466         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2467         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2468         /* unmute pins for output (no gain on this amp) */
2469         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2470         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2471         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2472         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2473
2474         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2475         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2476         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2477         /* Mic2 (as headphone out) for HP output */
2478         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2479         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2480         /* Line In pin widget for input */
2481         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2482         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2483         /* Line2 (as front mic) pin widget for input and vref at 80% */
2484         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2485         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2486         /* CD pin widget for input */
2487         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2488
2489         { }
2490 };
2491
2492 /*
2493  * W810 pin configuration:
2494  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2495  */
2496 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2497         /* hphone/speaker input selector: front DAC */
2498         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2499
2500         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2501         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2502         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2503         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2504         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2505         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2506
2507         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2508         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2509
2510         { }
2511 };
2512
2513 /*
2514  * Z71V pin configuration:
2515  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2516  */
2517 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2518         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2519         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2520         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2521         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2522
2523         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2524         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2525         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2526         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2527
2528         { }
2529 };
2530
2531 /*
2532  * 6-stack pin configuration:
2533  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2534  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2535  */
2536 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2537         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2538
2539         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2540         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2541         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2542         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2543         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2544         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2545         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2546         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2547
2548         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2549         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2550         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2551         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2552         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2553         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2554         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2555         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2556         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2557
2558         { }
2559 };
2560
2561 /*
2562  * Uniwill pin configuration:
2563  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2564  * line = 0x1a
2565  */
2566 static struct hda_verb alc880_uniwill_init_verbs[] = {
2567         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2568
2569         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2570         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2571         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2572         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2573         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2574         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2575         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2576         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2578         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2580         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2581         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2582         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2583
2584         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2585         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2586         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2587         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2588         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2589         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2590         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2591         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2592         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2593
2594         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2595         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2596
2597         { }
2598 };
2599
2600 /*
2601 * Uniwill P53
2602 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2603  */
2604 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2605         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2606
2607         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2608         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2609         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2610         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2611         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2612         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2613         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2614         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2615         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2616         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2617         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2618         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2619
2620         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2621         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2622         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2623         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2624         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2625         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2626
2627         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2628         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2629
2630         { }
2631 };
2632
2633 static struct hda_verb alc880_beep_init_verbs[] = {
2634         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2635         { }
2636 };
2637
2638 /* auto-toggle front mic */
2639 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2640 {
2641         unsigned int present;
2642         unsigned char bits;
2643
2644         present = snd_hda_codec_read(codec, 0x18, 0,
2645                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2646         bits = present ? HDA_AMP_MUTE : 0;
2647         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2648 }
2649
2650 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2651 {
2652         struct alc_spec *spec = codec->spec;
2653
2654         spec->autocfg.hp_pins[0] = 0x14;
2655         spec->autocfg.speaker_pins[0] = 0x15;
2656         spec->autocfg.speaker_pins[0] = 0x16;
2657         alc_automute_amp(codec);
2658         alc880_uniwill_mic_automute(codec);
2659 }
2660
2661 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2662                                        unsigned int res)
2663 {
2664         /* Looks like the unsol event is incompatible with the standard
2665          * definition.  4bit tag is placed at 28 bit!
2666          */
2667         switch (res >> 28) {
2668         case ALC880_MIC_EVENT:
2669                 alc880_uniwill_mic_automute(codec);
2670                 break;
2671         default:
2672                 alc_automute_amp_unsol_event(codec, res);
2673                 break;
2674         }
2675 }
2676
2677 static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
2678 {
2679         struct alc_spec *spec = codec->spec;
2680
2681         spec->autocfg.hp_pins[0] = 0x14;
2682         spec->autocfg.speaker_pins[0] = 0x15;
2683         alc_automute_amp(codec);
2684 }
2685
2686 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2687 {
2688         unsigned int present;
2689
2690         present = snd_hda_codec_read(codec, 0x21, 0,
2691                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2692         present &= HDA_AMP_VOLMASK;
2693         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2694                                  HDA_AMP_VOLMASK, present);
2695         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2696                                  HDA_AMP_VOLMASK, present);
2697 }
2698
2699 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2700                                            unsigned int res)
2701 {
2702         /* Looks like the unsol event is incompatible with the standard
2703          * definition.  4bit tag is placed at 28 bit!
2704          */
2705         if ((res >> 28) == ALC880_DCVOL_EVENT)
2706                 alc880_uniwill_p53_dcvol_automute(codec);
2707         else
2708                 alc_automute_amp_unsol_event(codec, res);
2709 }
2710
2711 /*
2712  * F1734 pin configuration:
2713  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2714  */
2715 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2716         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2717         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2718         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2719         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2720         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2721
2722         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2723         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2724         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2725         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2726
2727         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2728         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2729         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2730         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2731         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2732         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2733         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2734         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2735         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2736
2737         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2738         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2739
2740         { }
2741 };
2742
2743 /*
2744  * ASUS pin configuration:
2745  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2746  */
2747 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2748         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2749         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2750         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2751         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2752
2753         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2754         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2755         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2756         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2757         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2758         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2759         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2760         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2761
2762         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2763         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2765         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2767         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2768         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2769         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2770         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2771
2772         { }
2773 };
2774
2775 /* Enable GPIO mask and set output */
2776 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2777 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2778 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2779
2780 /* Clevo m520g init */
2781 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2782         /* headphone output */
2783         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2784         /* line-out */
2785         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2786         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2787         /* Line-in */
2788         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2789         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2790         /* CD */
2791         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2792         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2793         /* Mic1 (rear panel) */
2794         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2795         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2796         /* Mic2 (front panel) */
2797         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2798         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2799         /* headphone */
2800         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2801         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2802         /* change to EAPD mode */
2803         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2804         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2805
2806         { }
2807 };
2808
2809 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2810         /* change to EAPD mode */
2811         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2812         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2813
2814         /* Headphone output */
2815         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2816         /* Front output*/
2817         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2818         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2819
2820         /* Line In pin widget for input */
2821         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2822         /* CD pin widget for input */
2823         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2824         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2825         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2826
2827         /* change to EAPD mode */
2828         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2829         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2830
2831         { }
2832 };
2833
2834 /*
2835  * LG m1 express dual
2836  *
2837  * Pin assignment:
2838  *   Rear Line-In/Out (blue): 0x14
2839  *   Build-in Mic-In: 0x15
2840  *   Speaker-out: 0x17
2841  *   HP-Out (green): 0x1b
2842  *   Mic-In/Out (red): 0x19
2843  *   SPDIF-Out: 0x1e
2844  */
2845
2846 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2847 static hda_nid_t alc880_lg_dac_nids[3] = {
2848         0x05, 0x02, 0x03
2849 };
2850
2851 /* seems analog CD is not working */
2852 static struct hda_input_mux alc880_lg_capture_source = {
2853         .num_items = 3,
2854         .items = {
2855                 { "Mic", 0x1 },
2856                 { "Line", 0x5 },
2857                 { "Internal Mic", 0x6 },
2858         },
2859 };
2860
2861 /* 2,4,6 channel modes */
2862 static struct hda_verb alc880_lg_ch2_init[] = {
2863         /* set line-in and mic-in to input */
2864         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2865         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2866         { }
2867 };
2868
2869 static struct hda_verb alc880_lg_ch4_init[] = {
2870         /* set line-in to out and mic-in to input */
2871         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2872         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2873         { }
2874 };
2875
2876 static struct hda_verb alc880_lg_ch6_init[] = {
2877         /* set line-in and mic-in to output */
2878         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2879         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
2880         { }
2881 };
2882
2883 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
2884         { 2, alc880_lg_ch2_init },
2885         { 4, alc880_lg_ch4_init },
2886         { 6, alc880_lg_ch6_init },
2887 };
2888
2889 static struct snd_kcontrol_new alc880_lg_mixer[] = {
2890         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2891         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
2892         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2893         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
2894         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
2895         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
2896         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
2897         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
2898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2899         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
2901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
2902         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
2903         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
2904         {
2905                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2906                 .name = "Channel Mode",
2907                 .info = alc_ch_mode_info,
2908                 .get = alc_ch_mode_get,
2909                 .put = alc_ch_mode_put,
2910         },
2911         { } /* end */
2912 };
2913
2914 static struct hda_verb alc880_lg_init_verbs[] = {
2915         /* set capture source to mic-in */
2916         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2917         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2918         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
2919         /* mute all amp mixer inputs */
2920         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
2921         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2922         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2923         /* line-in to input */
2924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2925         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2926         /* built-in mic */
2927         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2928         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2929         /* speaker-out */
2930         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2931         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2932         /* mic-in to input */
2933         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2934         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2935         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2936         /* HP-out */
2937         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
2938         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2940         /* jack sense */
2941         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2942         { }
2943 };
2944
2945 /* toggle speaker-output according to the hp-jack state */
2946 static void alc880_lg_init_hook(struct hda_codec *codec)
2947 {
2948         struct alc_spec *spec = codec->spec;
2949
2950         spec->autocfg.hp_pins[0] = 0x1b;
2951         spec->autocfg.speaker_pins[0] = 0x17;
2952         alc_automute_amp(codec);
2953 }
2954
2955 /*
2956  * LG LW20
2957  *
2958  * Pin assignment:
2959  *   Speaker-out: 0x14
2960  *   Mic-In: 0x18
2961  *   Built-in Mic-In: 0x19
2962  *   Line-In: 0x1b
2963  *   HP-Out: 0x1a
2964  *   SPDIF-Out: 0x1e
2965  */
2966
2967 static struct hda_input_mux alc880_lg_lw_capture_source = {
2968         .num_items = 3,
2969         .items = {
2970                 { "Mic", 0x0 },
2971                 { "Internal Mic", 0x1 },
2972                 { "Line In", 0x2 },
2973         },
2974 };
2975
2976 #define alc880_lg_lw_modes alc880_threestack_modes
2977
2978 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
2979         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2980         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2981         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2982         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2983         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2984         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2985         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2986         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2987         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2988         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2989         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2990         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2991         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
2992         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
2993         {
2994                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2995                 .name = "Channel Mode",
2996                 .info = alc_ch_mode_info,
2997                 .get = alc_ch_mode_get,
2998                 .put = alc_ch_mode_put,
2999         },
3000         { } /* end */
3001 };
3002
3003 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3004         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3005         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3006         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3007
3008         /* set capture source to mic-in */
3009         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3010         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3011         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3012         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3013         /* speaker-out */
3014         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3015         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3016         /* HP-out */
3017         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3018         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3019         /* mic-in to input */
3020         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3021         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3022         /* built-in mic */
3023         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3024         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3025         /* jack sense */
3026         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3027         { }
3028 };
3029
3030 /* toggle speaker-output according to the hp-jack state */
3031 static void alc880_lg_lw_init_hook(struct hda_codec *codec)
3032 {
3033         struct alc_spec *spec = codec->spec;
3034
3035         spec->autocfg.hp_pins[0] = 0x1b;
3036         spec->autocfg.speaker_pins[0] = 0x14;
3037         alc_automute_amp(codec);
3038 }
3039
3040 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3041         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3042         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3043         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3044         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3045         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3046         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3047         { } /* end */
3048 };
3049
3050 static struct hda_input_mux alc880_medion_rim_capture_source = {
3051         .num_items = 2,
3052         .items = {
3053                 { "Mic", 0x0 },
3054                 { "Internal Mic", 0x1 },
3055         },
3056 };
3057
3058 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3059         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3060
3061         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3062         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3063
3064         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3065         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3066         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3067         /* Mic2 (as headphone out) for HP output */
3068         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3069         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3070         /* Internal Speaker */
3071         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3072         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3073
3074         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3075         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3076
3077         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3078         { }
3079 };
3080
3081 /* toggle speaker-output according to the hp-jack state */
3082 static void alc880_medion_rim_automute(struct hda_codec *codec)
3083 {
3084         struct alc_spec *spec = codec->spec;
3085         alc_automute_amp(codec);
3086         /* toggle EAPD */
3087         if (spec->jack_present)
3088                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3089         else
3090                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3091 }
3092
3093 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3094                                           unsigned int res)
3095 {
3096         /* Looks like the unsol event is incompatible with the standard
3097          * definition.  4bit tag is placed at 28 bit!
3098          */
3099         if ((res >> 28) == ALC880_HP_EVENT)
3100                 alc880_medion_rim_automute(codec);
3101 }
3102
3103 static void alc880_medion_rim_init_hook(struct hda_codec *codec)
3104 {
3105         struct alc_spec *spec = codec->spec;
3106
3107         spec->autocfg.hp_pins[0] = 0x14;
3108         spec->autocfg.speaker_pins[0] = 0x1b;
3109         alc880_medion_rim_automute(codec);
3110 }
3111
3112 #ifdef CONFIG_SND_HDA_POWER_SAVE
3113 static struct hda_amp_list alc880_loopbacks[] = {
3114         { 0x0b, HDA_INPUT, 0 },
3115         { 0x0b, HDA_INPUT, 1 },
3116         { 0x0b, HDA_INPUT, 2 },
3117         { 0x0b, HDA_INPUT, 3 },
3118         { 0x0b, HDA_INPUT, 4 },
3119         { } /* end */
3120 };
3121
3122 static struct hda_amp_list alc880_lg_loopbacks[] = {
3123         { 0x0b, HDA_INPUT, 1 },
3124         { 0x0b, HDA_INPUT, 6 },
3125         { 0x0b, HDA_INPUT, 7 },
3126         { } /* end */
3127 };
3128 #endif
3129
3130 /*
3131  * Common callbacks
3132  */
3133
3134 static int alc_init(struct hda_codec *codec)
3135 {
3136         struct alc_spec *spec = codec->spec;
3137         unsigned int i;
3138
3139         alc_fix_pll(codec);
3140         alc_auto_init_amp(codec, spec->init_amp);
3141
3142         for (i = 0; i < spec->num_init_verbs; i++)
3143                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3144
3145         if (spec->init_hook)
3146                 spec->init_hook(codec);
3147
3148         return 0;
3149 }
3150
3151 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3152 {
3153         struct alc_spec *spec = codec->spec;
3154
3155         if (spec->unsol_event)
3156                 spec->unsol_event(codec, res);
3157 }
3158
3159 #ifdef CONFIG_SND_HDA_POWER_SAVE
3160 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3161 {
3162         struct alc_spec *spec = codec->spec;
3163         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3164 }
3165 #endif
3166
3167 /*
3168  * Analog playback callbacks
3169  */
3170 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3171                                     struct hda_codec *codec,
3172                                     struct snd_pcm_substream *substream)
3173 {
3174         struct alc_spec *spec = codec->spec;
3175         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3176                                              hinfo);
3177 }
3178
3179 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3180                                        struct hda_codec *codec,
3181                                        unsigned int stream_tag,
3182                                        unsigned int format,
3183                                        struct snd_pcm_substream *substream)
3184 {
3185         struct alc_spec *spec = codec->spec;
3186         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3187                                                 stream_tag, format, substream);
3188 }
3189
3190 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3191                                        struct hda_codec *codec,
3192                                        struct snd_pcm_substream *substream)
3193 {
3194         struct alc_spec *spec = codec->spec;
3195         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3196 }
3197
3198 /*
3199  * Digital out
3200  */
3201 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3202                                         struct hda_codec *codec,
3203                                         struct snd_pcm_substream *substream)
3204 {
3205         struct alc_spec *spec = codec->spec;
3206         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3207 }
3208
3209 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3210                                            struct hda_codec *codec,
3211                                            unsigned int stream_tag,
3212                                            unsigned int format,
3213                                            struct snd_pcm_substream *substream)
3214 {
3215         struct alc_spec *spec = codec->spec;
3216         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3217                                              stream_tag, format, substream);
3218 }
3219
3220 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3221                                            struct hda_codec *codec,
3222                                            struct snd_pcm_substream *substream)
3223 {
3224         struct alc_spec *spec = codec->spec;
3225         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3226 }
3227
3228 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3229                                          struct hda_codec *codec,
3230                                          struct snd_pcm_substream *substream)
3231 {
3232         struct alc_spec *spec = codec->spec;
3233         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3234 }
3235
3236 /*
3237  * Analog capture
3238  */
3239 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3240                                       struct hda_codec *codec,
3241                                       unsigned int stream_tag,
3242                                       unsigned int format,
3243                                       struct snd_pcm_substream *substream)
3244 {
3245         struct alc_spec *spec = codec->spec;
3246
3247         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3248                                    stream_tag, 0, format);
3249         return 0;
3250 }
3251
3252 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3253                                       struct hda_codec *codec,
3254                                       struct snd_pcm_substream *substream)
3255 {
3256         struct alc_spec *spec = codec->spec;
3257
3258         snd_hda_codec_cleanup_stream(codec,
3259                                      spec->adc_nids[substream->number + 1]);
3260         return 0;
3261 }
3262
3263
3264 /*
3265  */
3266 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3267         .substreams = 1,
3268         .channels_min = 2,
3269         .channels_max = 8,
3270         /* NID is set in alc_build_pcms */
3271         .ops = {
3272                 .open = alc880_playback_pcm_open,
3273                 .prepare = alc880_playback_pcm_prepare,
3274                 .cleanup = alc880_playback_pcm_cleanup
3275         },
3276 };
3277
3278 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3279         .substreams = 1,
3280         .channels_min = 2,
3281         .channels_max = 2,
3282         /* NID is set in alc_build_pcms */
3283 };
3284
3285 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3286         .substreams = 1,
3287         .channels_min = 2,
3288         .channels_max = 2,
3289         /* NID is set in alc_build_pcms */
3290 };
3291
3292 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3293         .substreams = 2, /* can be overridden */
3294         .channels_min = 2,
3295         .channels_max = 2,
3296         /* NID is set in alc_build_pcms */
3297         .ops = {
3298                 .prepare = alc880_alt_capture_pcm_prepare,
3299                 .cleanup = alc880_alt_capture_pcm_cleanup
3300         },
3301 };
3302
3303 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3304         .substreams = 1,
3305         .channels_min = 2,
3306         .channels_max = 2,
3307         /* NID is set in alc_build_pcms */
3308         .ops = {
3309                 .open = alc880_dig_playback_pcm_open,
3310                 .close = alc880_dig_playback_pcm_close,
3311                 .prepare = alc880_dig_playback_pcm_prepare,
3312                 .cleanup = alc880_dig_playback_pcm_cleanup
3313         },
3314 };
3315
3316 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3317         .substreams = 1,
3318         .channels_min = 2,
3319         .channels_max = 2,
3320         /* NID is set in alc_build_pcms */
3321 };
3322
3323 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3324 static struct hda_pcm_stream alc_pcm_null_stream = {
3325         .substreams = 0,
3326         .channels_min = 0,
3327         .channels_max = 0,
3328 };
3329
3330 static int alc_build_pcms(struct hda_codec *codec)
3331 {
3332         struct alc_spec *spec = codec->spec;
3333         struct hda_pcm *info = spec->pcm_rec;
3334         int i;
3335
3336         codec->num_pcms = 1;
3337         codec->pcm_info = info;
3338
3339         if (spec->no_analog)
3340                 goto skip_analog;
3341
3342         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3343                  "%s Analog", codec->chip_name);
3344         info->name = spec->stream_name_analog;
3345
3346         if (spec->stream_analog_playback) {
3347                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3348                         return -EINVAL;
3349                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3350                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3351         }
3352         if (spec->stream_analog_capture) {
3353                 if (snd_BUG_ON(!spec->adc_nids))
3354                         return -EINVAL;
3355                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3356                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3357         }
3358
3359         if (spec->channel_mode) {
3360                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3361                 for (i = 0; i < spec->num_channel_mode; i++) {
3362                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3363                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3364                         }
3365                 }
3366         }
3367
3368  skip_analog:
3369         /* SPDIF for stream index #1 */
3370         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3371                 snprintf(spec->stream_name_digital,
3372                          sizeof(spec->stream_name_digital),
3373                          "%s Digital", codec->chip_name);
3374                 codec->num_pcms = 2;
3375                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3376                 info = spec->pcm_rec + 1;
3377                 info->name = spec->stream_name_digital;
3378                 if (spec->dig_out_type)
3379                         info->pcm_type = spec->dig_out_type;
3380                 else
3381                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3382                 if (spec->multiout.dig_out_nid &&
3383                     spec->stream_digital_playback) {
3384                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3385                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3386                 }
3387                 if (spec->dig_in_nid &&
3388                     spec->stream_digital_capture) {
3389                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3390                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3391                 }
3392                 /* FIXME: do we need this for all Realtek codec models? */
3393                 codec->spdif_status_reset = 1;
3394         }
3395
3396         if (spec->no_analog)
3397                 return 0;
3398
3399         /* If the use of more than one ADC is requested for the current
3400          * model, configure a second analog capture-only PCM.
3401          */
3402         /* Additional Analaog capture for index #2 */
3403         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3404             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3405                 codec->num_pcms = 3;
3406                 info = spec->pcm_rec + 2;
3407                 info->name = spec->stream_name_analog;
3408                 if (spec->alt_dac_nid) {
3409                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3410                                 *spec->stream_analog_alt_playback;
3411                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3412                                 spec->alt_dac_nid;
3413                 } else {
3414                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3415                                 alc_pcm_null_stream;
3416                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3417                 }
3418                 if (spec->num_adc_nids > 1) {
3419                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3420                                 *spec->stream_analog_alt_capture;
3421                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3422                                 spec->adc_nids[1];
3423                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3424                                 spec->num_adc_nids - 1;
3425                 } else {
3426                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3427                                 alc_pcm_null_stream;
3428                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3429                 }
3430         }
3431
3432         return 0;
3433 }
3434
3435 static void alc_free_kctls(struct hda_codec *codec)
3436 {
3437         struct alc_spec *spec = codec->spec;
3438
3439         if (spec->kctls.list) {
3440                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3441                 int i;
3442                 for (i = 0; i < spec->kctls.used; i++)
3443                         kfree(kctl[i].name);
3444         }
3445         snd_array_free(&spec->kctls);
3446 }
3447
3448 static void alc_free(struct hda_codec *codec)
3449 {
3450         struct alc_spec *spec = codec->spec;
3451
3452         if (!spec)
3453                 return;
3454
3455         alc_free_kctls(codec);
3456         kfree(spec);
3457         snd_hda_detach_beep_device(codec);
3458 }
3459
3460 #ifdef SND_HDA_NEEDS_RESUME
3461 static int alc_resume(struct hda_codec *codec)
3462 {
3463         codec->patch_ops.init(codec);
3464         snd_hda_codec_resume_amp(codec);
3465         snd_hda_codec_resume_cache(codec);
3466         return 0;
3467 }
3468 #endif
3469
3470 /*
3471  */
3472 static struct hda_codec_ops alc_patch_ops = {
3473         .build_controls = alc_build_controls,
3474         .build_pcms = alc_build_pcms,
3475         .init = alc_init,
3476         .free = alc_free,
3477         .unsol_event = alc_unsol_event,
3478 #ifdef SND_HDA_NEEDS_RESUME
3479         .resume = alc_resume,
3480 #endif
3481 #ifdef CONFIG_SND_HDA_POWER_SAVE
3482         .check_power_status = alc_check_power_status,
3483 #endif
3484 };
3485
3486
3487 /*
3488  * Test configuration for debugging
3489  *
3490  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3491  * enum controls.
3492  */
3493 #ifdef CONFIG_SND_DEBUG
3494 static hda_nid_t alc880_test_dac_nids[4] = {
3495         0x02, 0x03, 0x04, 0x05
3496 };
3497
3498 static struct hda_input_mux alc880_test_capture_source = {
3499         .num_items = 7,
3500         .items = {
3501                 { "In-1", 0x0 },
3502                 { "In-2", 0x1 },
3503                 { "In-3", 0x2 },
3504                 { "In-4", 0x3 },
3505                 { "CD", 0x4 },
3506                 { "Front", 0x5 },
3507                 { "Surround", 0x6 },
3508         },
3509 };
3510
3511 static struct hda_channel_mode alc880_test_modes[4] = {
3512         { 2, NULL },
3513         { 4, NULL },
3514         { 6, NULL },
3515         { 8, NULL },
3516 };
3517
3518 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3519                                  struct snd_ctl_elem_info *uinfo)
3520 {
3521         static char *texts[] = {
3522                 "N/A", "Line Out", "HP Out",
3523                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3524         };
3525         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3526         uinfo->count = 1;
3527         uinfo->value.enumerated.items = 8;
3528         if (uinfo->value.enumerated.item >= 8)
3529                 uinfo->value.enumerated.item = 7;
3530         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3531         return 0;
3532 }
3533
3534 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3535                                 struct snd_ctl_elem_value *ucontrol)
3536 {
3537         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3538         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3539         unsigned int pin_ctl, item = 0;
3540
3541         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3542                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3543         if (pin_ctl & AC_PINCTL_OUT_EN) {
3544                 if (pin_ctl & AC_PINCTL_HP_EN)
3545                         item = 2;
3546                 else
3547                         item = 1;
3548         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3549                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3550                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3551                 case AC_PINCTL_VREF_50:  item = 4; break;
3552                 case AC_PINCTL_VREF_GRD: item = 5; break;
3553                 case AC_PINCTL_VREF_80:  item = 6; break;
3554                 case AC_PINCTL_VREF_100: item = 7; break;
3555                 }
3556         }
3557         ucontrol->value.enumerated.item[0] = item;
3558         return 0;
3559 }
3560
3561 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3562                                 struct snd_ctl_elem_value *ucontrol)
3563 {
3564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3565         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3566         static unsigned int ctls[] = {
3567                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3568                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3569                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3570                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3571                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3572                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3573         };
3574         unsigned int old_ctl, new_ctl;
3575
3576         old_ctl = snd_hda_codec_read(codec, nid, 0,
3577                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3578         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3579         if (old_ctl != new_ctl) {
3580                 int val;
3581                 snd_hda_codec_write_cache(codec, nid, 0,
3582                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3583                                           new_ctl);
3584                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3585                         HDA_AMP_MUTE : 0;
3586                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3587                                          HDA_AMP_MUTE, val);
3588                 return 1;
3589         }
3590         return 0;
3591 }
3592
3593 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3594                                  struct snd_ctl_elem_info *uinfo)
3595 {
3596         static char *texts[] = {
3597                 "Front", "Surround", "CLFE", "Side"
3598         };
3599         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3600         uinfo->count = 1;
3601         uinfo->value.enumerated.items = 4;
3602         if (uinfo->value.enumerated.item >= 4)
3603                 uinfo->value.enumerated.item = 3;
3604         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3605         return 0;
3606 }
3607
3608 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3609                                 struct snd_ctl_elem_value *ucontrol)
3610 {
3611         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3612         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3613         unsigned int sel;
3614
3615         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3616         ucontrol->value.enumerated.item[0] = sel & 3;
3617         return 0;
3618 }
3619
3620 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3621                                 struct snd_ctl_elem_value *ucontrol)
3622 {
3623         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3624         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3625         unsigned int sel;
3626
3627         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3628         if (ucontrol->value.enumerated.item[0] != sel) {
3629                 sel = ucontrol->value.enumerated.item[0] & 3;
3630                 snd_hda_codec_write_cache(codec, nid, 0,
3631                                           AC_VERB_SET_CONNECT_SEL, sel);
3632                 return 1;
3633         }
3634         return 0;
3635 }
3636
3637 #define PIN_CTL_TEST(xname,nid) {                       \
3638                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3639                         .name = xname,                 \
3640                         .info = alc_test_pin_ctl_info, \
3641                         .get = alc_test_pin_ctl_get,   \
3642                         .put = alc_test_pin_ctl_put,   \
3643                         .private_value = nid           \
3644                         }
3645
3646 #define PIN_SRC_TEST(xname,nid) {                       \
3647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3648                         .name = xname,                 \
3649                         .info = alc_test_pin_src_info, \
3650                         .get = alc_test_pin_src_get,   \
3651                         .put = alc_test_pin_src_put,   \
3652                         .private_value = nid           \
3653                         }
3654
3655 static struct snd_kcontrol_new alc880_test_mixer[] = {
3656         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3657         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3658         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3659         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3660         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3661         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3662         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3663         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3664         PIN_CTL_TEST("Front Pin Mode", 0x14),
3665         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3666         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3667         PIN_CTL_TEST("Side Pin Mode", 0x17),
3668         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3669         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3670         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3671         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3672         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3673         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3674         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3675         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3676         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3677         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3678         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3679         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3680         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3681         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3682         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3683         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3684         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3685         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3686         {
3687                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3688                 .name = "Channel Mode",
3689                 .info = alc_ch_mode_info,
3690                 .get = alc_ch_mode_get,
3691                 .put = alc_ch_mode_put,
3692         },
3693         { } /* end */
3694 };
3695
3696 static struct hda_verb alc880_test_init_verbs[] = {
3697         /* Unmute inputs of 0x0c - 0x0f */
3698         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3699         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3700         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3701         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3702         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3703         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3704         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3705         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3706         /* Vol output for 0x0c-0x0f */
3707         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3708         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3709         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3710         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3711         /* Set output pins 0x14-0x17 */
3712         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3713         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3714         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3715         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3716         /* Unmute output pins 0x14-0x17 */
3717         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3718         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3719         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3720         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3721         /* Set input pins 0x18-0x1c */
3722         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3723         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3724         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3725         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3726         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3727         /* Mute input pins 0x18-0x1b */
3728         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3729         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3730         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3731         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3732         /* ADC set up */
3733         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3734         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3735         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3736         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3737         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3738         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3739         /* Analog input/passthru */
3740         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3741         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3742         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3743         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3744         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3745         { }
3746 };
3747 #endif
3748
3749 /*
3750  */
3751
3752 static const char *alc880_models[ALC880_MODEL_LAST] = {
3753         [ALC880_3ST]            = "3stack",
3754         [ALC880_TCL_S700]       = "tcl",
3755         [ALC880_3ST_DIG]        = "3stack-digout",
3756         [ALC880_CLEVO]          = "clevo",
3757         [ALC880_5ST]            = "5stack",
3758         [ALC880_5ST_DIG]        = "5stack-digout",
3759         [ALC880_W810]           = "w810",
3760         [ALC880_Z71V]           = "z71v",
3761         [ALC880_6ST]            = "6stack",
3762         [ALC880_6ST_DIG]        = "6stack-digout",
3763         [ALC880_ASUS]           = "asus",
3764         [ALC880_ASUS_W1V]       = "asus-w1v",
3765         [ALC880_ASUS_DIG]       = "asus-dig",
3766         [ALC880_ASUS_DIG2]      = "asus-dig2",
3767         [ALC880_UNIWILL_DIG]    = "uniwill",
3768         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3769         [ALC880_FUJITSU]        = "fujitsu",
3770         [ALC880_F1734]          = "F1734",
3771         [ALC880_LG]             = "lg",
3772         [ALC880_LG_LW]          = "lg-lw",
3773         [ALC880_MEDION_RIM]     = "medion",
3774 #ifdef CONFIG_SND_DEBUG
3775         [ALC880_TEST]           = "test",
3776 #endif
3777         [ALC880_AUTO]           = "auto",
3778 };
3779
3780 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3781         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3782         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3783         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3784         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3785         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3786         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3787         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3788         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3789         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3790         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3791         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3792         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3793         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3794         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3795         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3796         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3797         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3798         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3799         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3800         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3801         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3802         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3803         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3804         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3805         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3806         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3807         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3808         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3809         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3810         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3811         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3812         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3813         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3814         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3815         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3816         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3817         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3818         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3819         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3820         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3821         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3822         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3823         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3824         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3825         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3826         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3827         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3828         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3829         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3830         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3831         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3832         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3833         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3834         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3835         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3836         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3837         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3838         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3839         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3840         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3841         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3842         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3843         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3844         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3845         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3846         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3847         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3848         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3849         /* default Intel */
3850         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3851         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3852         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3853         {}
3854 };
3855
3856 /*
3857  * ALC880 codec presets
3858  */
3859 static struct alc_config_preset alc880_presets[] = {
3860         [ALC880_3ST] = {
3861                 .mixers = { alc880_three_stack_mixer },
3862                 .init_verbs = { alc880_volume_init_verbs,
3863                                 alc880_pin_3stack_init_verbs },
3864                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3865                 .dac_nids = alc880_dac_nids,
3866                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3867                 .channel_mode = alc880_threestack_modes,
3868                 .need_dac_fix = 1,
3869                 .input_mux = &alc880_capture_source,
3870         },
3871         [ALC880_3ST_DIG] = {
3872                 .mixers = { alc880_three_stack_mixer },
3873                 .init_verbs = { alc880_volume_init_verbs,
3874                                 alc880_pin_3stack_init_verbs },
3875                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3876                 .dac_nids = alc880_dac_nids,
3877                 .dig_out_nid = ALC880_DIGOUT_NID,
3878                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
3879                 .channel_mode = alc880_threestack_modes,
3880                 .need_dac_fix = 1,
3881                 .input_mux = &alc880_capture_source,
3882         },
3883         [ALC880_TCL_S700] = {
3884                 .mixers = { alc880_tcl_s700_mixer },
3885                 .init_verbs = { alc880_volume_init_verbs,
3886                                 alc880_pin_tcl_S700_init_verbs,
3887                                 alc880_gpio2_init_verbs },
3888                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3889                 .dac_nids = alc880_dac_nids,
3890                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
3891                 .num_adc_nids = 1, /* single ADC */
3892                 .hp_nid = 0x03,
3893                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3894                 .channel_mode = alc880_2_jack_modes,
3895                 .input_mux = &alc880_capture_source,
3896         },
3897         [ALC880_5ST] = {
3898                 .mixers = { alc880_three_stack_mixer,
3899                             alc880_five_stack_mixer},
3900                 .init_verbs = { alc880_volume_init_verbs,
3901                                 alc880_pin_5stack_init_verbs },
3902                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3903                 .dac_nids = alc880_dac_nids,
3904                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3905                 .channel_mode = alc880_fivestack_modes,
3906                 .input_mux = &alc880_capture_source,
3907         },
3908         [ALC880_5ST_DIG] = {
3909                 .mixers = { alc880_three_stack_mixer,
3910                             alc880_five_stack_mixer },
3911                 .init_verbs = { alc880_volume_init_verbs,
3912                                 alc880_pin_5stack_init_verbs },
3913                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3914                 .dac_nids = alc880_dac_nids,
3915                 .dig_out_nid = ALC880_DIGOUT_NID,
3916                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
3917                 .channel_mode = alc880_fivestack_modes,
3918                 .input_mux = &alc880_capture_source,
3919         },
3920         [ALC880_6ST] = {
3921                 .mixers = { alc880_six_stack_mixer },
3922                 .init_verbs = { alc880_volume_init_verbs,
3923                                 alc880_pin_6stack_init_verbs },
3924                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3925                 .dac_nids = alc880_6st_dac_nids,
3926                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3927                 .channel_mode = alc880_sixstack_modes,
3928                 .input_mux = &alc880_6stack_capture_source,
3929         },
3930         [ALC880_6ST_DIG] = {
3931                 .mixers = { alc880_six_stack_mixer },
3932                 .init_verbs = { alc880_volume_init_verbs,
3933                                 alc880_pin_6stack_init_verbs },
3934                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
3935                 .dac_nids = alc880_6st_dac_nids,
3936                 .dig_out_nid = ALC880_DIGOUT_NID,
3937                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
3938                 .channel_mode = alc880_sixstack_modes,
3939                 .input_mux = &alc880_6stack_capture_source,
3940         },
3941         [ALC880_W810] = {
3942                 .mixers = { alc880_w810_base_mixer },
3943                 .init_verbs = { alc880_volume_init_verbs,
3944                                 alc880_pin_w810_init_verbs,
3945                                 alc880_gpio2_init_verbs },
3946                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
3947                 .dac_nids = alc880_w810_dac_nids,
3948                 .dig_out_nid = ALC880_DIGOUT_NID,
3949                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
3950                 .channel_mode = alc880_w810_modes,
3951                 .input_mux = &alc880_capture_source,
3952         },
3953         [ALC880_Z71V] = {
3954                 .mixers = { alc880_z71v_mixer },
3955                 .init_verbs = { alc880_volume_init_verbs,
3956                                 alc880_pin_z71v_init_verbs },
3957                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
3958                 .dac_nids = alc880_z71v_dac_nids,
3959                 .dig_out_nid = ALC880_DIGOUT_NID,
3960                 .hp_nid = 0x03,
3961                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3962                 .channel_mode = alc880_2_jack_modes,
3963                 .input_mux = &alc880_capture_source,
3964         },
3965         [ALC880_F1734] = {
3966                 .mixers = { alc880_f1734_mixer },
3967                 .init_verbs = { alc880_volume_init_verbs,
3968                                 alc880_pin_f1734_init_verbs },
3969                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
3970                 .dac_nids = alc880_f1734_dac_nids,
3971                 .hp_nid = 0x02,
3972                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
3973                 .channel_mode = alc880_2_jack_modes,
3974                 .input_mux = &alc880_f1734_capture_source,
3975                 .unsol_event = alc880_uniwill_p53_unsol_event,
3976                 .init_hook = alc880_uniwill_p53_init_hook,
3977         },
3978         [ALC880_ASUS] = {
3979                 .mixers = { alc880_asus_mixer },
3980                 .init_verbs = { alc880_volume_init_verbs,
3981                                 alc880_pin_asus_init_verbs,
3982                                 alc880_gpio1_init_verbs },
3983                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3984                 .dac_nids = alc880_asus_dac_nids,
3985                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3986                 .channel_mode = alc880_asus_modes,
3987                 .need_dac_fix = 1,
3988                 .input_mux = &alc880_capture_source,
3989         },
3990         [ALC880_ASUS_DIG] = {
3991                 .mixers = { alc880_asus_mixer },
3992                 .init_verbs = { alc880_volume_init_verbs,
3993                                 alc880_pin_asus_init_verbs,
3994                                 alc880_gpio1_init_verbs },
3995                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
3996                 .dac_nids = alc880_asus_dac_nids,
3997                 .dig_out_nid = ALC880_DIGOUT_NID,
3998                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
3999                 .channel_mode = alc880_asus_modes,
4000                 .need_dac_fix = 1,
4001                 .input_mux = &alc880_capture_source,
4002         },
4003         [ALC880_ASUS_DIG2] = {
4004                 .mixers = { alc880_asus_mixer },
4005                 .init_verbs = { alc880_volume_init_verbs,
4006                                 alc880_pin_asus_init_verbs,
4007                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4008                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4009                 .dac_nids = alc880_asus_dac_nids,
4010                 .dig_out_nid = ALC880_DIGOUT_NID,
4011                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4012                 .channel_mode = alc880_asus_modes,
4013                 .need_dac_fix = 1,
4014                 .input_mux = &alc880_capture_source,
4015         },
4016         [ALC880_ASUS_W1V] = {
4017                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4018                 .init_verbs = { alc880_volume_init_verbs,
4019                                 alc880_pin_asus_init_verbs,
4020                                 alc880_gpio1_init_verbs },
4021                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4022                 .dac_nids = alc880_asus_dac_nids,
4023                 .dig_out_nid = ALC880_DIGOUT_NID,
4024                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4025                 .channel_mode = alc880_asus_modes,
4026                 .need_dac_fix = 1,
4027                 .input_mux = &alc880_capture_source,
4028         },
4029         [ALC880_UNIWILL_DIG] = {
4030                 .mixers = { alc880_asus_mixer },
4031                 .init_verbs = { alc880_volume_init_verbs,
4032                                 alc880_pin_asus_init_verbs },
4033                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4034                 .dac_nids = alc880_asus_dac_nids,
4035                 .dig_out_nid = ALC880_DIGOUT_NID,
4036                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4037                 .channel_mode = alc880_asus_modes,
4038                 .need_dac_fix = 1,
4039                 .input_mux = &alc880_capture_source,
4040         },
4041         [ALC880_UNIWILL] = {
4042                 .mixers = { alc880_uniwill_mixer },
4043                 .init_verbs = { alc880_volume_init_verbs,
4044                                 alc880_uniwill_init_verbs },
4045                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4046                 .dac_nids = alc880_asus_dac_nids,
4047                 .dig_out_nid = ALC880_DIGOUT_NID,
4048                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4049                 .channel_mode = alc880_threestack_modes,
4050                 .need_dac_fix = 1,
4051                 .input_mux = &alc880_capture_source,
4052                 .unsol_event = alc880_uniwill_unsol_event,
4053                 .init_hook = alc880_uniwill_init_hook,
4054         },
4055         [ALC880_UNIWILL_P53] = {
4056                 .mixers = { alc880_uniwill_p53_mixer },
4057                 .init_verbs = { alc880_volume_init_verbs,
4058                                 alc880_uniwill_p53_init_verbs },
4059                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4060                 .dac_nids = alc880_asus_dac_nids,
4061                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4062                 .channel_mode = alc880_threestack_modes,
4063                 .input_mux = &alc880_capture_source,
4064                 .unsol_event = alc880_uniwill_p53_unsol_event,
4065                 .init_hook = alc880_uniwill_p53_init_hook,
4066         },
4067         [ALC880_FUJITSU] = {
4068                 .mixers = { alc880_fujitsu_mixer },
4069                 .init_verbs = { alc880_volume_init_verbs,
4070                                 alc880_uniwill_p53_init_verbs,
4071                                 alc880_beep_init_verbs },
4072                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4073                 .dac_nids = alc880_dac_nids,
4074                 .dig_out_nid = ALC880_DIGOUT_NID,
4075                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4076                 .channel_mode = alc880_2_jack_modes,
4077                 .input_mux = &alc880_capture_source,
4078                 .unsol_event = alc880_uniwill_p53_unsol_event,
4079                 .init_hook = alc880_uniwill_p53_init_hook,
4080         },
4081         [ALC880_CLEVO] = {
4082                 .mixers = { alc880_three_stack_mixer },
4083                 .init_verbs = { alc880_volume_init_verbs,
4084                                 alc880_pin_clevo_init_verbs },
4085                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4086                 .dac_nids = alc880_dac_nids,
4087                 .hp_nid = 0x03,
4088                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4089                 .channel_mode = alc880_threestack_modes,
4090                 .need_dac_fix = 1,
4091                 .input_mux = &alc880_capture_source,
4092         },
4093         [ALC880_LG] = {
4094                 .mixers = { alc880_lg_mixer },
4095                 .init_verbs = { alc880_volume_init_verbs,
4096                                 alc880_lg_init_verbs },
4097                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4098                 .dac_nids = alc880_lg_dac_nids,
4099                 .dig_out_nid = ALC880_DIGOUT_NID,
4100                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4101                 .channel_mode = alc880_lg_ch_modes,
4102                 .need_dac_fix = 1,
4103                 .input_mux = &alc880_lg_capture_source,
4104                 .unsol_event = alc_automute_amp_unsol_event,
4105                 .init_hook = alc880_lg_init_hook,
4106 #ifdef CONFIG_SND_HDA_POWER_SAVE
4107                 .loopbacks = alc880_lg_loopbacks,
4108 #endif
4109         },
4110         [ALC880_LG_LW] = {
4111                 .mixers = { alc880_lg_lw_mixer },
4112                 .init_verbs = { alc880_volume_init_verbs,
4113                                 alc880_lg_lw_init_verbs },
4114                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4115                 .dac_nids = alc880_dac_nids,
4116                 .dig_out_nid = ALC880_DIGOUT_NID,
4117                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4118                 .channel_mode = alc880_lg_lw_modes,
4119                 .input_mux = &alc880_lg_lw_capture_source,
4120                 .unsol_event = alc_automute_amp_unsol_event,
4121                 .init_hook = alc880_lg_lw_init_hook,
4122         },
4123         [ALC880_MEDION_RIM] = {
4124                 .mixers = { alc880_medion_rim_mixer },
4125                 .init_verbs = { alc880_volume_init_verbs,
4126                                 alc880_medion_rim_init_verbs,
4127                                 alc_gpio2_init_verbs },
4128                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4129                 .dac_nids = alc880_dac_nids,
4130                 .dig_out_nid = ALC880_DIGOUT_NID,
4131                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4132                 .channel_mode = alc880_2_jack_modes,
4133                 .input_mux = &alc880_medion_rim_capture_source,
4134                 .unsol_event = alc880_medion_rim_unsol_event,
4135                 .init_hook = alc880_medion_rim_init_hook,
4136         },
4137 #ifdef CONFIG_SND_DEBUG
4138         [ALC880_TEST] = {
4139                 .mixers = { alc880_test_mixer },
4140                 .init_verbs = { alc880_test_init_verbs },
4141                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4142                 .dac_nids = alc880_test_dac_nids,
4143                 .dig_out_nid = ALC880_DIGOUT_NID,
4144                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4145                 .channel_mode = alc880_test_modes,
4146                 .input_mux = &alc880_test_capture_source,
4147         },
4148 #endif
4149 };
4150
4151 /*
4152  * Automatic parse of I/O pins from the BIOS configuration
4153  */
4154
4155 enum {
4156         ALC_CTL_WIDGET_VOL,
4157         ALC_CTL_WIDGET_MUTE,
4158         ALC_CTL_BIND_MUTE,
4159 };
4160 static struct snd_kcontrol_new alc880_control_templates[] = {
4161         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4162         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4163         HDA_BIND_MUTE(NULL, 0, 0, 0),
4164 };
4165
4166 /* add dynamic controls */
4167 static int add_control(struct alc_spec *spec, int type, const char *name,
4168                        unsigned long val)
4169 {
4170         struct snd_kcontrol_new *knew;
4171
4172         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4173         knew = snd_array_new(&spec->kctls);
4174         if (!knew)
4175                 return -ENOMEM;
4176         *knew = alc880_control_templates[type];
4177         knew->name = kstrdup(name, GFP_KERNEL);
4178         if (!knew->name)
4179                 return -ENOMEM;
4180         knew->private_value = val;
4181         return 0;
4182 }
4183
4184 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4185 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4186 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4187 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4188 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
4189 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
4190 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4191 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4192 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4193 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4194 #define ALC880_PIN_CD_NID               0x1c
4195
4196 /* fill in the dac_nids table from the parsed pin configuration */
4197 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4198                                      const struct auto_pin_cfg *cfg)
4199 {
4200         hda_nid_t nid;
4201         int assigned[4];
4202         int i, j;
4203
4204         memset(assigned, 0, sizeof(assigned));
4205         spec->multiout.dac_nids = spec->private_dac_nids;
4206
4207         /* check the pins hardwired to audio widget */
4208         for (i = 0; i < cfg->line_outs; i++) {
4209                 nid = cfg->line_out_pins[i];
4210                 if (alc880_is_fixed_pin(nid)) {
4211                         int idx = alc880_fixed_pin_idx(nid);
4212                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4213                         assigned[idx] = 1;
4214                 }
4215         }
4216         /* left pins can be connect to any audio widget */
4217         for (i = 0; i < cfg->line_outs; i++) {
4218                 nid = cfg->line_out_pins[i];
4219                 if (alc880_is_fixed_pin(nid))
4220                         continue;
4221                 /* search for an empty channel */
4222                 for (j = 0; j < cfg->line_outs; j++) {
4223                         if (!assigned[j]) {
4224                                 spec->multiout.dac_nids[i] =
4225                                         alc880_idx_to_dac(j);
4226                                 assigned[j] = 1;
4227                                 break;
4228                         }
4229                 }
4230         }
4231         spec->multiout.num_dacs = cfg->line_outs;
4232         return 0;
4233 }
4234
4235 /* add playback controls from the parsed DAC table */
4236 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4237                                              const struct auto_pin_cfg *cfg)
4238 {
4239         char name[32];
4240         static const char *chname[4] = {
4241                 "Front", "Surround", NULL /*CLFE*/, "Side"
4242         };
4243         hda_nid_t nid;
4244         int i, err;
4245
4246         for (i = 0; i < cfg->line_outs; i++) {
4247                 if (!spec->multiout.dac_nids[i])
4248                         continue;
4249                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4250                 if (i == 2) {
4251                         /* Center/LFE */
4252                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4253                                           "Center Playback Volume",
4254                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4255                                                               HDA_OUTPUT));
4256                         if (err < 0)
4257                                 return err;
4258                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4259                                           "LFE Playback Volume",
4260                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4261                                                               HDA_OUTPUT));
4262                         if (err < 0)
4263                                 return err;
4264                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4265                                           "Center Playback Switch",
4266                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4267                                                               HDA_INPUT));
4268                         if (err < 0)
4269                                 return err;
4270                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4271                                           "LFE Playback Switch",
4272                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4273                                                               HDA_INPUT));
4274                         if (err < 0)
4275                                 return err;
4276                 } else {
4277                         sprintf(name, "%s Playback Volume", chname[i]);
4278                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4279                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4280                                                               HDA_OUTPUT));
4281                         if (err < 0)
4282                                 return err;
4283                         sprintf(name, "%s Playback Switch", chname[i]);
4284                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4285                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4286                                                               HDA_INPUT));
4287                         if (err < 0)
4288                                 return err;
4289                 }
4290         }
4291         return 0;
4292 }
4293
4294 /* add playback controls for speaker and HP outputs */
4295 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4296                                         const char *pfx)
4297 {
4298         hda_nid_t nid;
4299         int err;
4300         char name[32];
4301
4302         if (!pin)
4303                 return 0;
4304
4305         if (alc880_is_fixed_pin(pin)) {
4306                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4307                 /* specify the DAC as the extra output */
4308                 if (!spec->multiout.hp_nid)
4309                         spec->multiout.hp_nid = nid;
4310                 else
4311                         spec->multiout.extra_out_nid[0] = nid;
4312                 /* control HP volume/switch on the output mixer amp */
4313                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4314                 sprintf(name, "%s Playback Volume", pfx);
4315                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4316                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4317                 if (err < 0)
4318                         return err;
4319                 sprintf(name, "%s Playback Switch", pfx);
4320                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4321                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4322                 if (err < 0)
4323                         return err;
4324         } else if (alc880_is_multi_pin(pin)) {
4325                 /* set manual connection */
4326                 /* we have only a switch on HP-out PIN */
4327                 sprintf(name, "%s Playback Switch", pfx);
4328                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4329                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4330                 if (err < 0)
4331                         return err;
4332         }
4333         return 0;
4334 }
4335
4336 /* create input playback/capture controls for the given pin */
4337 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4338                             const char *ctlname,
4339                             int idx, hda_nid_t mix_nid)
4340 {
4341         char name[32];
4342         int err;
4343
4344         sprintf(name, "%s Playback Volume", ctlname);
4345         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4346                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4347         if (err < 0)
4348                 return err;
4349         sprintf(name, "%s Playback Switch", ctlname);
4350         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4351                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4352         if (err < 0)
4353                 return err;
4354         return 0;
4355 }
4356
4357 /* create playback/capture controls for input pins */
4358 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4359                                                 const struct auto_pin_cfg *cfg)
4360 {
4361         struct hda_input_mux *imux = &spec->private_imux[0];
4362         int i, err, idx;
4363
4364         for (i = 0; i < AUTO_PIN_LAST; i++) {
4365                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4366                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4367                         err = new_analog_input(spec, cfg->input_pins[i],
4368                                                auto_pin_cfg_labels[i],
4369                                                idx, 0x0b);
4370                         if (err < 0)
4371                                 return err;
4372                         imux->items[imux->num_items].label =
4373                                 auto_pin_cfg_labels[i];
4374                         imux->items[imux->num_items].index =
4375                                 alc880_input_pin_idx(cfg->input_pins[i]);
4376                         imux->num_items++;
4377                 }
4378         }
4379         return 0;
4380 }
4381
4382 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4383                                unsigned int pin_type)
4384 {
4385         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4386                             pin_type);
4387         /* unmute pin */
4388         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4389                             AMP_OUT_UNMUTE);
4390 }
4391
4392 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4393                                               hda_nid_t nid, int pin_type,
4394                                               int dac_idx)
4395 {
4396         alc_set_pin_output(codec, nid, pin_type);
4397         /* need the manual connection? */
4398         if (alc880_is_multi_pin(nid)) {
4399                 struct alc_spec *spec = codec->spec;
4400                 int idx = alc880_multi_pin_idx(nid);
4401                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4402                                     AC_VERB_SET_CONNECT_SEL,
4403                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4404         }
4405 }
4406
4407 static int get_pin_type(int line_out_type)
4408 {
4409         if (line_out_type == AUTO_PIN_HP_OUT)
4410                 return PIN_HP;
4411         else
4412                 return PIN_OUT;
4413 }
4414
4415 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4416 {
4417         struct alc_spec *spec = codec->spec;
4418         int i;
4419
4420         for (i = 0; i < spec->autocfg.line_outs; i++) {
4421                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4422                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4423                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4424         }
4425 }
4426
4427 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4428 {
4429         struct alc_spec *spec = codec->spec;
4430         hda_nid_t pin;
4431
4432         pin = spec->autocfg.speaker_pins[0];
4433         if (pin) /* connect to front */
4434                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4435         pin = spec->autocfg.hp_pins[0];
4436         if (pin) /* connect to front */
4437                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4438 }
4439
4440 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4441 {
4442         struct alc_spec *spec = codec->spec;
4443         int i;
4444
4445         for (i = 0; i < AUTO_PIN_LAST; i++) {
4446                 hda_nid_t nid = spec->autocfg.input_pins[i];
4447                 if (alc880_is_input_pin(nid)) {
4448                         alc_set_input_pin(codec, nid, i);
4449                         if (nid != ALC880_PIN_CD_NID &&
4450                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4451                                 snd_hda_codec_write(codec, nid, 0,
4452                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4453                                                     AMP_OUT_MUTE);
4454                 }
4455         }
4456 }
4457
4458 /* parse the BIOS configuration and set up the alc_spec */
4459 /* return 1 if successful, 0 if the proper config is not found,
4460  * or a negative error code
4461  */
4462 static int alc880_parse_auto_config(struct hda_codec *codec)
4463 {
4464         struct alc_spec *spec = codec->spec;
4465         int i, err;
4466         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4467
4468         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4469                                            alc880_ignore);
4470         if (err < 0)
4471                 return err;
4472         if (!spec->autocfg.line_outs)
4473                 return 0; /* can't find valid BIOS pin config */
4474
4475         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4476         if (err < 0)
4477                 return err;
4478         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4479         if (err < 0)
4480                 return err;
4481         err = alc880_auto_create_extra_out(spec,
4482                                            spec->autocfg.speaker_pins[0],
4483                                            "Speaker");
4484         if (err < 0)
4485                 return err;
4486         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4487                                            "Headphone");
4488         if (err < 0)
4489                 return err;
4490         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4491         if (err < 0)
4492                 return err;
4493
4494         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4495
4496         /* check multiple SPDIF-out (for recent codecs) */
4497         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4498                 hda_nid_t dig_nid;
4499                 err = snd_hda_get_connections(codec,
4500                                               spec->autocfg.dig_out_pins[i],
4501                                               &dig_nid, 1);
4502                 if (err < 0)
4503                         continue;
4504                 if (!i)
4505                         spec->multiout.dig_out_nid = dig_nid;
4506                 else {
4507                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4508                         spec->slave_dig_outs[i - 1] = dig_nid;
4509                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4510                                 break;
4511                 }
4512         }
4513         if (spec->autocfg.dig_in_pin)
4514                 spec->dig_in_nid = ALC880_DIGIN_NID;
4515
4516         if (spec->kctls.list)
4517                 add_mixer(spec, spec->kctls.list);
4518
4519         add_verb(spec, alc880_volume_init_verbs);
4520
4521         spec->num_mux_defs = 1;
4522         spec->input_mux = &spec->private_imux[0];
4523
4524         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4525
4526         return 1;
4527 }
4528
4529 /* additional initialization for auto-configuration model */
4530 static void alc880_auto_init(struct hda_codec *codec)
4531 {
4532         struct alc_spec *spec = codec->spec;
4533         alc880_auto_init_multi_out(codec);
4534         alc880_auto_init_extra_out(codec);
4535         alc880_auto_init_analog_input(codec);
4536         if (spec->unsol_event)
4537                 alc_inithook(codec);
4538 }
4539
4540 static void set_capture_mixer(struct alc_spec *spec)
4541 {
4542         static struct snd_kcontrol_new *caps[2][3] = {
4543                 { alc_capture_mixer_nosrc1,
4544                   alc_capture_mixer_nosrc2,
4545                   alc_capture_mixer_nosrc3 },
4546                 { alc_capture_mixer1,
4547                   alc_capture_mixer2,
4548                   alc_capture_mixer3 },
4549         };
4550         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4551                 int mux;
4552                 if (spec->input_mux && spec->input_mux->num_items > 1)
4553                         mux = 1;
4554                 else
4555                         mux = 0;
4556                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4557         }
4558 }
4559
4560 #define set_beep_amp(spec, nid, idx, dir) \
4561         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4562
4563 /*
4564  * OK, here we have finally the patch for ALC880
4565  */
4566
4567 static int patch_alc880(struct hda_codec *codec)
4568 {
4569         struct alc_spec *spec;
4570         int board_config;
4571         int err;
4572
4573         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4574         if (spec == NULL)
4575                 return -ENOMEM;
4576
4577         codec->spec = spec;
4578
4579         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4580                                                   alc880_models,
4581                                                   alc880_cfg_tbl);
4582         if (board_config < 0) {
4583                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
4584                        "trying auto-probe from BIOS...\n", codec->chip_name);
4585                 board_config = ALC880_AUTO;
4586         }
4587
4588         if (board_config == ALC880_AUTO) {
4589                 /* automatic parse from the BIOS config */
4590                 err = alc880_parse_auto_config(codec);
4591                 if (err < 0) {
4592                         alc_free(codec);
4593                         return err;
4594                 } else if (!err) {
4595                         printk(KERN_INFO
4596                                "hda_codec: Cannot set up configuration "
4597                                "from BIOS.  Using 3-stack mode...\n");
4598                         board_config = ALC880_3ST;
4599                 }
4600         }
4601
4602         err = snd_hda_attach_beep_device(codec, 0x1);
4603         if (err < 0) {
4604                 alc_free(codec);
4605                 return err;
4606         }
4607
4608         if (board_config != ALC880_AUTO)
4609                 setup_preset(spec, &alc880_presets[board_config]);
4610
4611         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4612         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4613         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4614
4615         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4616         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4617
4618         if (!spec->adc_nids && spec->input_mux) {
4619                 /* check whether NID 0x07 is valid */
4620                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4621                 /* get type */
4622                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
4623                 if (wcap != AC_WID_AUD_IN) {
4624                         spec->adc_nids = alc880_adc_nids_alt;
4625                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4626                 } else {
4627                         spec->adc_nids = alc880_adc_nids;
4628                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4629                 }
4630         }
4631         set_capture_mixer(spec);
4632         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4633
4634         spec->vmaster_nid = 0x0c;
4635
4636         codec->patch_ops = alc_patch_ops;
4637         if (board_config == ALC880_AUTO)
4638                 spec->init_hook = alc880_auto_init;
4639 #ifdef CONFIG_SND_HDA_POWER_SAVE
4640         if (!spec->loopback.amplist)
4641                 spec->loopback.amplist = alc880_loopbacks;
4642 #endif
4643         codec->proc_widget_hook = print_realtek_coef;
4644
4645         return 0;
4646 }
4647
4648
4649 /*
4650  * ALC260 support
4651  */
4652
4653 static hda_nid_t alc260_dac_nids[1] = {
4654         /* front */
4655         0x02,
4656 };
4657
4658 static hda_nid_t alc260_adc_nids[1] = {
4659         /* ADC0 */
4660         0x04,
4661 };
4662
4663 static hda_nid_t alc260_adc_nids_alt[1] = {
4664         /* ADC1 */
4665         0x05,
4666 };
4667
4668 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4669  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4670  */
4671 static hda_nid_t alc260_dual_adc_nids[2] = {
4672         /* ADC0, ADC1 */
4673         0x04, 0x05
4674 };
4675
4676 #define ALC260_DIGOUT_NID       0x03
4677 #define ALC260_DIGIN_NID        0x06
4678
4679 static struct hda_input_mux alc260_capture_source = {
4680         .num_items = 4,
4681         .items = {
4682                 { "Mic", 0x0 },
4683                 { "Front Mic", 0x1 },
4684                 { "Line", 0x2 },
4685                 { "CD", 0x4 },
4686         },
4687 };
4688
4689 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4690  * headphone jack and the internal CD lines since these are the only pins at
4691  * which audio can appear.  For flexibility, also allow the option of
4692  * recording the mixer output on the second ADC (ADC0 doesn't have a
4693  * connection to the mixer output).
4694  */
4695 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4696         {
4697                 .num_items = 3,
4698                 .items = {
4699                         { "Mic/Line", 0x0 },
4700                         { "CD", 0x4 },
4701                         { "Headphone", 0x2 },
4702                 },
4703         },
4704         {
4705                 .num_items = 4,
4706                 .items = {
4707                         { "Mic/Line", 0x0 },
4708                         { "CD", 0x4 },
4709                         { "Headphone", 0x2 },
4710                         { "Mixer", 0x5 },
4711                 },
4712         },
4713
4714 };
4715
4716 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4717  * the Fujitsu S702x, but jacks are marked differently.
4718  */
4719 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4720         {
4721                 .num_items = 4,
4722                 .items = {
4723                         { "Mic", 0x0 },
4724                         { "Line", 0x2 },
4725                         { "CD", 0x4 },
4726                         { "Headphone", 0x5 },
4727                 },
4728         },
4729         {
4730                 .num_items = 5,
4731                 .items = {
4732                         { "Mic", 0x0 },
4733                         { "Line", 0x2 },
4734                         { "CD", 0x4 },
4735                         { "Headphone", 0x6 },
4736                         { "Mixer", 0x5 },
4737                 },
4738         },
4739 };
4740
4741 /* Maxdata Favorit 100XS */
4742 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4743         {
4744                 .num_items = 2,
4745                 .items = {
4746                         { "Line/Mic", 0x0 },
4747                         { "CD", 0x4 },
4748                 },
4749         },
4750         {
4751                 .num_items = 3,
4752                 .items = {
4753                         { "Line/Mic", 0x0 },
4754                         { "CD", 0x4 },
4755                         { "Mixer", 0x5 },
4756                 },
4757         },
4758 };
4759
4760 /*
4761  * This is just place-holder, so there's something for alc_build_pcms to look
4762  * at when it calculates the maximum number of channels. ALC260 has no mixer
4763  * element which allows changing the channel mode, so the verb list is
4764  * never used.
4765  */
4766 static struct hda_channel_mode alc260_modes[1] = {
4767         { 2, NULL },
4768 };
4769
4770
4771 /* Mixer combinations
4772  *
4773  * basic: base_output + input + pc_beep + capture
4774  * HP: base_output + input + capture_alt
4775  * HP_3013: hp_3013 + input + capture
4776  * fujitsu: fujitsu + capture
4777  * acer: acer + capture
4778  */
4779
4780 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4781         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4782         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4783         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4784         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4785         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4786         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4787         { } /* end */
4788 };
4789
4790 static struct snd_kcontrol_new alc260_input_mixer[] = {
4791         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4792         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4793         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4794         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4795         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4796         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4797         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4798         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4799         { } /* end */
4800 };
4801
4802 /* update HP, line and mono out pins according to the master switch */
4803 static void alc260_hp_master_update(struct hda_codec *codec,
4804                                     hda_nid_t hp, hda_nid_t line,
4805                                     hda_nid_t mono)
4806 {
4807         struct alc_spec *spec = codec->spec;
4808         unsigned int val = spec->master_sw ? PIN_HP : 0;
4809         /* change HP and line-out pins */
4810         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4811                             val);
4812         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4813                             val);
4814         /* mono (speaker) depending on the HP jack sense */
4815         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4816         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4817                             val);
4818 }
4819
4820 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4821                                    struct snd_ctl_elem_value *ucontrol)
4822 {
4823         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4824         struct alc_spec *spec = codec->spec;
4825         *ucontrol->value.integer.value = spec->master_sw;
4826         return 0;
4827 }
4828
4829 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4830                                    struct snd_ctl_elem_value *ucontrol)
4831 {
4832         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4833         struct alc_spec *spec = codec->spec;
4834         int val = !!*ucontrol->value.integer.value;
4835         hda_nid_t hp, line, mono;
4836
4837         if (val == spec->master_sw)
4838                 return 0;
4839         spec->master_sw = val;
4840         hp = (kcontrol->private_value >> 16) & 0xff;
4841         line = (kcontrol->private_value >> 8) & 0xff;
4842         mono = kcontrol->private_value & 0xff;
4843         alc260_hp_master_update(codec, hp, line, mono);
4844         return 1;
4845 }
4846
4847 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4848         {
4849                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4850                 .name = "Master Playback Switch",
4851                 .info = snd_ctl_boolean_mono_info,
4852                 .get = alc260_hp_master_sw_get,
4853                 .put = alc260_hp_master_sw_put,
4854                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4855         },
4856         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4857         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4858         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4859         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4860         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4861                               HDA_OUTPUT),
4862         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4863         { } /* end */
4864 };
4865
4866 static struct hda_verb alc260_hp_unsol_verbs[] = {
4867         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4868         {},
4869 };
4870
4871 static void alc260_hp_automute(struct hda_codec *codec)
4872 {
4873         struct alc_spec *spec = codec->spec;
4874         unsigned int present;
4875
4876         present = snd_hda_codec_read(codec, 0x10, 0,
4877                                      AC_VERB_GET_PIN_SENSE, 0);
4878         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4879         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
4880 }
4881
4882 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
4883 {
4884         if ((res >> 26) == ALC880_HP_EVENT)
4885                 alc260_hp_automute(codec);
4886 }
4887
4888 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
4889         {
4890                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4891                 .name = "Master Playback Switch",
4892                 .info = snd_ctl_boolean_mono_info,
4893                 .get = alc260_hp_master_sw_get,
4894                 .put = alc260_hp_master_sw_put,
4895                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
4896         },
4897         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4898         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4899         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
4900         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
4901         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4902         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
4903         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4904         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
4905         { } /* end */
4906 };
4907
4908 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
4909         .ops = &snd_hda_bind_vol,
4910         .values = {
4911                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
4912                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
4913                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
4914                 0
4915         },
4916 };
4917
4918 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
4919         .ops = &snd_hda_bind_sw,
4920         .values = {
4921                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
4922                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
4923                 0
4924         },
4925 };
4926
4927 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
4928         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
4929         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
4930         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
4931         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
4932         { } /* end */
4933 };
4934
4935 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
4936         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
4937         {},
4938 };
4939
4940 static void alc260_hp_3013_automute(struct hda_codec *codec)
4941 {
4942         struct alc_spec *spec = codec->spec;
4943         unsigned int present;
4944
4945         present = snd_hda_codec_read(codec, 0x15, 0,
4946                                      AC_VERB_GET_PIN_SENSE, 0);
4947         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
4948         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
4949 }
4950
4951 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
4952                                        unsigned int res)
4953 {
4954         if ((res >> 26) == ALC880_HP_EVENT)
4955                 alc260_hp_3013_automute(codec);
4956 }
4957
4958 static void alc260_hp_3012_automute(struct hda_codec *codec)
4959 {
4960         unsigned int present, bits;
4961
4962         present = snd_hda_codec_read(codec, 0x10, 0,
4963                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
4964
4965         bits = present ? 0 : PIN_OUT;
4966         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4967                             bits);
4968         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4969                             bits);
4970         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4971                             bits);
4972 }
4973
4974 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
4975                                        unsigned int res)
4976 {
4977         if ((res >> 26) == ALC880_HP_EVENT)
4978                 alc260_hp_3012_automute(codec);
4979 }
4980
4981 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
4982  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
4983  */
4984 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
4985         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4986         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
4987         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
4988         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4989         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4990         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
4991         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
4992         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
4993         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4994         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
4995         { } /* end */
4996 };
4997
4998 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
4999  * versions of the ALC260 don't act on requests to enable mic bias from NID
5000  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5001  * datasheet doesn't mention this restriction.  At this stage it's not clear
5002  * whether this behaviour is intentional or is a hardware bug in chip
5003  * revisions available in early 2006.  Therefore for now allow the
5004  * "Headphone Jack Mode" control to span all choices, but if it turns out
5005  * that the lack of mic bias for this NID is intentional we could change the
5006  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5007  *
5008  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5009  * don't appear to make the mic bias available from the "line" jack, even
5010  * though the NID used for this jack (0x14) can supply it.  The theory is
5011  * that perhaps Acer have included blocking capacitors between the ALC260
5012  * and the output jack.  If this turns out to be the case for all such
5013  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5014  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5015  *
5016  * The C20x Tablet series have a mono internal speaker which is controlled
5017  * via the chip's Mono sum widget and pin complex, so include the necessary
5018  * controls for such models.  On models without a "mono speaker" the control
5019  * won't do anything.
5020  */
5021 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5022         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5023         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5024         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5025         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5026                               HDA_OUTPUT),
5027         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5028                            HDA_INPUT),
5029         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5030         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5031         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5032         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5033         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5034         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5035         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5036         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5037         { } /* end */
5038 };
5039
5040 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5041  */
5042 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5043         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5044         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5045         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5046         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5047         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5048         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5049         { } /* end */
5050 };
5051
5052 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5053  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5054  */
5055 static struct snd_kcontrol_new alc260_will_mixer[] = {
5056         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5057         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5058         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5059         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5060         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5061         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5062         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5063         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5064         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5065         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5066         { } /* end */
5067 };
5068
5069 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5070  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5071  */
5072 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5073         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5074         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5075         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5076         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5077         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5078         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5079         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5080         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5081         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5082         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5083         { } /* end */
5084 };
5085
5086 /*
5087  * initialization verbs
5088  */
5089 static struct hda_verb alc260_init_verbs[] = {
5090         /* Line In pin widget for input */
5091         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5092         /* CD pin widget for input */
5093         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5094         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5095         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5096         /* Mic2 (front panel) pin widget for input and vref at 80% */
5097         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5098         /* LINE-2 is used for line-out in rear */
5099         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5100         /* select line-out */
5101         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5102         /* LINE-OUT pin */
5103         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5104         /* enable HP */
5105         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5106         /* enable Mono */
5107         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5108         /* mute capture amp left and right */
5109         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5110         /* set connection select to line in (default select for this ADC) */
5111         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5112         /* mute capture amp left and right */
5113         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5114         /* set connection select to line in (default select for this ADC) */
5115         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5116         /* set vol=0 Line-Out mixer amp left and right */
5117         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5118         /* unmute pin widget amp left and right (no gain on this amp) */
5119         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5120         /* set vol=0 HP mixer amp left and right */
5121         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5122         /* unmute pin widget amp left and right (no gain on this amp) */
5123         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5124         /* set vol=0 Mono mixer amp left and right */
5125         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5126         /* unmute pin widget amp left and right (no gain on this amp) */
5127         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5128         /* unmute LINE-2 out pin */
5129         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5130         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5131          * Line In 2 = 0x03
5132          */
5133         /* mute analog inputs */
5134         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5135         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5136         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5137         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5138         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5139         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5140         /* mute Front out path */
5141         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5142         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5143         /* mute Headphone out path */
5144         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5145         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5146         /* mute Mono out path */
5147         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5148         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5149         { }
5150 };
5151
5152 #if 0 /* should be identical with alc260_init_verbs? */
5153 static struct hda_verb alc260_hp_init_verbs[] = {
5154         /* Headphone and output */
5155         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5156         /* mono output */
5157         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5158         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5159         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5160         /* Mic2 (front panel) pin widget for input and vref at 80% */
5161         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5162         /* Line In pin widget for input */
5163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5164         /* Line-2 pin widget for output */
5165         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5166         /* CD pin widget for input */
5167         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5168         /* unmute amp left and right */
5169         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5170         /* set connection select to line in (default select for this ADC) */
5171         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5172         /* unmute Line-Out mixer amp left and right (volume = 0) */
5173         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5174         /* mute pin widget amp left and right (no gain on this amp) */
5175         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5176         /* unmute HP mixer amp left and right (volume = 0) */
5177         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5178         /* mute pin widget amp left and right (no gain on this amp) */
5179         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5180         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5181          * Line In 2 = 0x03
5182          */
5183         /* mute analog inputs */
5184         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5185         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5186         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5187         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5188         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5189         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5190         /* Unmute Front out path */
5191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5192         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5193         /* Unmute Headphone out path */
5194         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5195         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5196         /* Unmute Mono out path */
5197         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5198         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5199         { }
5200 };
5201 #endif
5202
5203 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5204         /* Line out and output */
5205         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5206         /* mono output */
5207         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5208         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5209         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5210         /* Mic2 (front panel) pin widget for input and vref at 80% */
5211         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5212         /* Line In pin widget for input */
5213         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5214         /* Headphone pin widget for output */
5215         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5216         /* CD pin widget for input */
5217         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5218         /* unmute amp left and right */
5219         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5220         /* set connection select to line in (default select for this ADC) */
5221         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5222         /* unmute Line-Out mixer amp left and right (volume = 0) */
5223         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5224         /* mute pin widget amp left and right (no gain on this amp) */
5225         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5226         /* unmute HP mixer amp left and right (volume = 0) */
5227         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5228         /* mute pin widget amp left and right (no gain on this amp) */
5229         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5230         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5231          * Line In 2 = 0x03
5232          */
5233         /* mute analog inputs */
5234         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5235         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5236         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5237         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5239         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5240         /* Unmute Front out path */
5241         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5242         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5243         /* Unmute Headphone out path */
5244         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5245         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5246         /* Unmute Mono out path */
5247         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5248         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5249         { }
5250 };
5251
5252 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5253  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5254  * audio = 0x16, internal speaker = 0x10.
5255  */
5256 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5257         /* Disable all GPIOs */
5258         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5259         /* Internal speaker is connected to headphone pin */
5260         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5261         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5262         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5263         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5264         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5265         /* Ensure all other unused pins are disabled and muted. */
5266         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5267         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5268         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5269         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5270         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5271         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5272         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5273         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5274
5275         /* Disable digital (SPDIF) pins */
5276         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5277         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5278
5279         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5280          * when acting as an output.
5281          */
5282         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5283
5284         /* Start with output sum widgets muted and their output gains at min */
5285         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5286         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5287         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5288         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5289         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5290         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5291         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5292         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5293         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5294
5295         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5296         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5297         /* Unmute Line1 pin widget output buffer since it starts as an output.
5298          * If the pin mode is changed by the user the pin mode control will
5299          * take care of enabling the pin's input/output buffers as needed.
5300          * Therefore there's no need to enable the input buffer at this
5301          * stage.
5302          */
5303         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5304         /* Unmute input buffer of pin widget used for Line-in (no equiv
5305          * mixer ctrl)
5306          */
5307         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5308
5309         /* Mute capture amp left and right */
5310         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5311         /* Set ADC connection select to match default mixer setting - line
5312          * in (on mic1 pin)
5313          */
5314         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5315
5316         /* Do the same for the second ADC: mute capture input amp and
5317          * set ADC connection to line in (on mic1 pin)
5318          */
5319         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5320         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5321
5322         /* Mute all inputs to mixer widget (even unconnected ones) */
5323         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5324         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5325         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5326         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5327         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5328         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5329         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5330         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5331
5332         { }
5333 };
5334
5335 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5336  * similar laptops (adapted from Fujitsu init verbs).
5337  */
5338 static struct hda_verb alc260_acer_init_verbs[] = {
5339         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5340          * the headphone jack.  Turn this on and rely on the standard mute
5341          * methods whenever the user wants to turn these outputs off.
5342          */
5343         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5344         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5345         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5346         /* Internal speaker/Headphone jack is connected to Line-out pin */
5347         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5348         /* Internal microphone/Mic jack is connected to Mic1 pin */
5349         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5350         /* Line In jack is connected to Line1 pin */
5351         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5352         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5353         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5354         /* Ensure all other unused pins are disabled and muted. */
5355         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5356         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5357         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5358         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5359         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5360         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5361         /* Disable digital (SPDIF) pins */
5362         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5363         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5364
5365         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5366          * bus when acting as outputs.
5367          */
5368         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5369         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5370
5371         /* Start with output sum widgets muted and their output gains at min */
5372         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5373         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5374         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5375         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5376         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5377         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5378         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5379         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5380         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5381
5382         /* Unmute Line-out pin widget amp left and right
5383          * (no equiv mixer ctrl)
5384          */
5385         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5386         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5387         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5388         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5389          * inputs. If the pin mode is changed by the user the pin mode control
5390          * will take care of enabling the pin's input/output buffers as needed.
5391          * Therefore there's no need to enable the input buffer at this
5392          * stage.
5393          */
5394         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5395         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5396
5397         /* Mute capture amp left and right */
5398         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5399         /* Set ADC connection select to match default mixer setting - mic
5400          * (on mic1 pin)
5401          */
5402         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5403
5404         /* Do similar with the second ADC: mute capture input amp and
5405          * set ADC connection to mic to match ALSA's default state.
5406          */
5407         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5408         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5409
5410         /* Mute all inputs to mixer widget (even unconnected ones) */
5411         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5412         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5413         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5414         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5415         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5416         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5417         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5418         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5419
5420         { }
5421 };
5422
5423 /* Initialisation sequence for Maxdata Favorit 100XS
5424  * (adapted from Acer init verbs).
5425  */
5426 static struct hda_verb alc260_favorit100_init_verbs[] = {
5427         /* GPIO 0 enables the output jack.
5428          * Turn this on and rely on the standard mute
5429          * methods whenever the user wants to turn these outputs off.
5430          */
5431         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5432         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5433         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5434         /* Line/Mic input jack is connected to Mic1 pin */
5435         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5436         /* Ensure all other unused pins are disabled and muted. */
5437         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5438         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5439         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5440         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5441         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5442         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5443         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5444         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5445         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5446         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5447         /* Disable digital (SPDIF) pins */
5448         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5449         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5450
5451         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5452          * bus when acting as outputs.
5453          */
5454         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5455         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5456
5457         /* Start with output sum widgets muted and their output gains at min */
5458         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5459         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5460         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5461         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5462         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5463         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5464         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5465         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5466         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5467
5468         /* Unmute Line-out pin widget amp left and right
5469          * (no equiv mixer ctrl)
5470          */
5471         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5472         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5473          * inputs. If the pin mode is changed by the user the pin mode control
5474          * will take care of enabling the pin's input/output buffers as needed.
5475          * Therefore there's no need to enable the input buffer at this
5476          * stage.
5477          */
5478         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5479
5480         /* Mute capture amp left and right */
5481         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5482         /* Set ADC connection select to match default mixer setting - mic
5483          * (on mic1 pin)
5484          */
5485         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5486
5487         /* Do similar with the second ADC: mute capture input amp and
5488          * set ADC connection to mic to match ALSA's default state.
5489          */
5490         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5491         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5492
5493         /* Mute all inputs to mixer widget (even unconnected ones) */
5494         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5495         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5496         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5497         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5498         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5500         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5501         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5502
5503         { }
5504 };
5505
5506 static struct hda_verb alc260_will_verbs[] = {
5507         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5508         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5509         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5510         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5511         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5512         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5513         {}
5514 };
5515
5516 static struct hda_verb alc260_replacer_672v_verbs[] = {
5517         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5518         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5519         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5520
5521         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5522         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5523         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5524
5525         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5526         {}
5527 };
5528
5529 /* toggle speaker-output according to the hp-jack state */
5530 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5531 {
5532         unsigned int present;
5533
5534         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5535         present = snd_hda_codec_read(codec, 0x0f, 0,
5536                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5537         if (present) {
5538                 snd_hda_codec_write_cache(codec, 0x01, 0,
5539                                           AC_VERB_SET_GPIO_DATA, 1);
5540                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5541                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5542                                           PIN_HP);
5543         } else {
5544                 snd_hda_codec_write_cache(codec, 0x01, 0,
5545                                           AC_VERB_SET_GPIO_DATA, 0);
5546                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5547                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5548                                           PIN_OUT);
5549         }
5550 }
5551
5552 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5553                                        unsigned int res)
5554 {
5555         if ((res >> 26) == ALC880_HP_EVENT)
5556                 alc260_replacer_672v_automute(codec);
5557 }
5558
5559 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5560         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5561         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5562         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5563         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5564         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5565         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5566         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5567         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5568         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5569         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5570         {}
5571 };
5572
5573 /* Test configuration for debugging, modelled after the ALC880 test
5574  * configuration.
5575  */
5576 #ifdef CONFIG_SND_DEBUG
5577 static hda_nid_t alc260_test_dac_nids[1] = {
5578         0x02,
5579 };
5580 static hda_nid_t alc260_test_adc_nids[2] = {
5581         0x04, 0x05,
5582 };
5583 /* For testing the ALC260, each input MUX needs its own definition since
5584  * the signal assignments are different.  This assumes that the first ADC
5585  * is NID 0x04.
5586  */
5587 static struct hda_input_mux alc260_test_capture_sources[2] = {
5588         {
5589                 .num_items = 7,
5590                 .items = {
5591                         { "MIC1 pin", 0x0 },
5592                         { "MIC2 pin", 0x1 },
5593                         { "LINE1 pin", 0x2 },
5594                         { "LINE2 pin", 0x3 },
5595                         { "CD pin", 0x4 },
5596                         { "LINE-OUT pin", 0x5 },
5597                         { "HP-OUT pin", 0x6 },
5598                 },
5599         },
5600         {
5601                 .num_items = 8,
5602                 .items = {
5603                         { "MIC1 pin", 0x0 },
5604                         { "MIC2 pin", 0x1 },
5605                         { "LINE1 pin", 0x2 },
5606                         { "LINE2 pin", 0x3 },
5607                         { "CD pin", 0x4 },
5608                         { "Mixer", 0x5 },
5609                         { "LINE-OUT pin", 0x6 },
5610                         { "HP-OUT pin", 0x7 },
5611                 },
5612         },
5613 };
5614 static struct snd_kcontrol_new alc260_test_mixer[] = {
5615         /* Output driver widgets */
5616         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5617         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5618         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5619         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5620         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5621         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5622
5623         /* Modes for retasking pin widgets
5624          * Note: the ALC260 doesn't seem to act on requests to enable mic
5625          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5626          * mention this restriction.  At this stage it's not clear whether
5627          * this behaviour is intentional or is a hardware bug in chip
5628          * revisions available at least up until early 2006.  Therefore for
5629          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5630          * choices, but if it turns out that the lack of mic bias for these
5631          * NIDs is intentional we could change their modes from
5632          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5633          */
5634         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5635         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5636         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5637         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5638         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5639         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5640
5641         /* Loopback mixer controls */
5642         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5643         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5644         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5645         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5646         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5647         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5648         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5649         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5650         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5651         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5652         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5653         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5654         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5655         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5656
5657         /* Controls for GPIO pins, assuming they are configured as outputs */
5658         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5659         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5660         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5661         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5662
5663         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5664          * is ambigious as to which NID is which; testing on laptops which
5665          * make this output available should provide clarification.
5666          */
5667         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5668         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5669
5670         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5671          * this output to turn on an external amplifier.
5672          */
5673         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5674         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5675
5676         { } /* end */
5677 };
5678 static struct hda_verb alc260_test_init_verbs[] = {
5679         /* Enable all GPIOs as outputs with an initial value of 0 */
5680         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5681         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5682         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5683
5684         /* Enable retasking pins as output, initially without power amp */
5685         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5686         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5688         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5689         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5690         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5691
5692         /* Disable digital (SPDIF) pins initially, but users can enable
5693          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5694          * payload also sets the generation to 0, output to be in "consumer"
5695          * PCM format, copyright asserted, no pre-emphasis and no validity
5696          * control.
5697          */
5698         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5699         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5700
5701         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5702          * OUT1 sum bus when acting as an output.
5703          */
5704         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5705         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5706         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5707         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5708
5709         /* Start with output sum widgets muted and their output gains at min */
5710         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5711         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5712         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5713         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5714         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5715         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5716         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5717         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5718         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5719
5720         /* Unmute retasking pin widget output buffers since the default
5721          * state appears to be output.  As the pin mode is changed by the
5722          * user the pin mode control will take care of enabling the pin's
5723          * input/output buffers as needed.
5724          */
5725         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5726         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5727         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5728         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5729         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5730         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5731         /* Also unmute the mono-out pin widget */
5732         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5733
5734         /* Mute capture amp left and right */
5735         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5736         /* Set ADC connection select to match default mixer setting (mic1
5737          * pin)
5738          */
5739         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5740
5741         /* Do the same for the second ADC: mute capture input amp and
5742          * set ADC connection to mic1 pin
5743          */
5744         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5745         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5746
5747         /* Mute all inputs to mixer widget (even unconnected ones) */
5748         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5749         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5750         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5751         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5752         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5754         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5755         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5756
5757         { }
5758 };
5759 #endif
5760
5761 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5762 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5763
5764 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5765 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5766
5767 /*
5768  * for BIOS auto-configuration
5769  */
5770
5771 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5772                                         const char *pfx, int *vol_bits)
5773 {
5774         hda_nid_t nid_vol;
5775         unsigned long vol_val, sw_val;
5776         char name[32];
5777         int err;
5778
5779         if (nid >= 0x0f && nid < 0x11) {
5780                 nid_vol = nid - 0x7;
5781                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5782                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5783         } else if (nid == 0x11) {
5784                 nid_vol = nid - 0x7;
5785                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5786                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5787         } else if (nid >= 0x12 && nid <= 0x15) {
5788                 nid_vol = 0x08;
5789                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5790                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5791         } else
5792                 return 0; /* N/A */
5793
5794         if (!(*vol_bits & (1 << nid_vol))) {
5795                 /* first control for the volume widget */
5796                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5797                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5798                 if (err < 0)
5799                         return err;
5800                 *vol_bits |= (1 << nid_vol);
5801         }
5802         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5803         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5804         if (err < 0)
5805                 return err;
5806         return 1;
5807 }
5808
5809 /* add playback controls from the parsed DAC table */
5810 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5811                                              const struct auto_pin_cfg *cfg)
5812 {
5813         hda_nid_t nid;
5814         int err;
5815         int vols = 0;
5816
5817         spec->multiout.num_dacs = 1;
5818         spec->multiout.dac_nids = spec->private_dac_nids;
5819         spec->multiout.dac_nids[0] = 0x02;
5820
5821         nid = cfg->line_out_pins[0];
5822         if (nid) {
5823                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5824                 if (err < 0)
5825                         return err;
5826         }
5827
5828         nid = cfg->speaker_pins[0];
5829         if (nid) {
5830                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5831                 if (err < 0)
5832                         return err;
5833         }
5834
5835         nid = cfg->hp_pins[0];
5836         if (nid) {
5837                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5838                                                    &vols);
5839                 if (err < 0)
5840                         return err;
5841         }
5842         return 0;
5843 }
5844
5845 /* create playback/capture controls for input pins */
5846 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5847                                                 const struct auto_pin_cfg *cfg)
5848 {
5849         struct hda_input_mux *imux = &spec->private_imux[0];
5850         int i, err, idx;
5851
5852         for (i = 0; i < AUTO_PIN_LAST; i++) {
5853                 if (cfg->input_pins[i] >= 0x12) {
5854                         idx = cfg->input_pins[i] - 0x12;
5855                         err = new_analog_input(spec, cfg->input_pins[i],
5856                                                auto_pin_cfg_labels[i], idx,
5857                                                0x07);
5858                         if (err < 0)
5859                                 return err;
5860                         imux->items[imux->num_items].label =
5861                                 auto_pin_cfg_labels[i];
5862                         imux->items[imux->num_items].index = idx;
5863                         imux->num_items++;
5864                 }
5865                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
5866                         idx = cfg->input_pins[i] - 0x09;
5867                         err = new_analog_input(spec, cfg->input_pins[i],
5868                                                auto_pin_cfg_labels[i], idx,
5869                                                0x07);
5870                         if (err < 0)
5871                                 return err;
5872                         imux->items[imux->num_items].label =
5873                                 auto_pin_cfg_labels[i];
5874                         imux->items[imux->num_items].index = idx;
5875                         imux->num_items++;
5876                 }
5877         }
5878         return 0;
5879 }
5880
5881 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
5882                                               hda_nid_t nid, int pin_type,
5883                                               int sel_idx)
5884 {
5885         alc_set_pin_output(codec, nid, pin_type);
5886         /* need the manual connection? */
5887         if (nid >= 0x12) {
5888                 int idx = nid - 0x12;
5889                 snd_hda_codec_write(codec, idx + 0x0b, 0,
5890                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
5891         }
5892 }
5893
5894 static void alc260_auto_init_multi_out(struct hda_codec *codec)
5895 {
5896         struct alc_spec *spec = codec->spec;
5897         hda_nid_t nid;
5898
5899         nid = spec->autocfg.line_out_pins[0];
5900         if (nid) {
5901                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5902                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
5903         }
5904
5905         nid = spec->autocfg.speaker_pins[0];
5906         if (nid)
5907                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
5908
5909         nid = spec->autocfg.hp_pins[0];
5910         if (nid)
5911                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
5912 }
5913
5914 #define ALC260_PIN_CD_NID               0x16
5915 static void alc260_auto_init_analog_input(struct hda_codec *codec)
5916 {
5917         struct alc_spec *spec = codec->spec;
5918         int i;
5919
5920         for (i = 0; i < AUTO_PIN_LAST; i++) {
5921                 hda_nid_t nid = spec->autocfg.input_pins[i];
5922                 if (nid >= 0x12) {
5923                         alc_set_input_pin(codec, nid, i);
5924                         if (nid != ALC260_PIN_CD_NID &&
5925                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5926                                 snd_hda_codec_write(codec, nid, 0,
5927                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5928                                                     AMP_OUT_MUTE);
5929                 }
5930         }
5931 }
5932
5933 /*
5934  * generic initialization of ADC, input mixers and output mixers
5935  */
5936 static struct hda_verb alc260_volume_init_verbs[] = {
5937         /*
5938          * Unmute ADC0-1 and set the default input to mic-in
5939          */
5940         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5941         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5942         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5943         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5944
5945         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
5946          * mixer widget
5947          * Note: PASD motherboards uses the Line In 2 as the input for
5948          * front panel mic (mic 2)
5949          */
5950         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
5951         /* mute analog inputs */
5952         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5953         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5954         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5955         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5956         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5957
5958         /*
5959          * Set up output mixers (0x08 - 0x0a)
5960          */
5961         /* set vol=0 to output mixers */
5962         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5963         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5964         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5965         /* set up input amps for analog loopback */
5966         /* Amp Indices: DAC = 0, mixer = 1 */
5967         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5968         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5969         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5970         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5971         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5972         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
5973
5974         { }
5975 };
5976
5977 static int alc260_parse_auto_config(struct hda_codec *codec)
5978 {
5979         struct alc_spec *spec = codec->spec;
5980         int err;
5981         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
5982
5983         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5984                                            alc260_ignore);
5985         if (err < 0)
5986                 return err;
5987         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
5988         if (err < 0)
5989                 return err;
5990         if (!spec->kctls.list)
5991                 return 0; /* can't find valid BIOS pin config */
5992         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
5993         if (err < 0)
5994                 return err;
5995
5996         spec->multiout.max_channels = 2;
5997
5998         if (spec->autocfg.dig_outs)
5999                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6000         if (spec->kctls.list)
6001                 add_mixer(spec, spec->kctls.list);
6002
6003         add_verb(spec, alc260_volume_init_verbs);
6004
6005         spec->num_mux_defs = 1;
6006         spec->input_mux = &spec->private_imux[0];
6007
6008         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6009
6010         return 1;
6011 }
6012
6013 /* additional initialization for auto-configuration model */
6014 static void alc260_auto_init(struct hda_codec *codec)
6015 {
6016         struct alc_spec *spec = codec->spec;
6017         alc260_auto_init_multi_out(codec);
6018         alc260_auto_init_analog_input(codec);
6019         if (spec->unsol_event)
6020                 alc_inithook(codec);
6021 }
6022
6023 #ifdef CONFIG_SND_HDA_POWER_SAVE
6024 static struct hda_amp_list alc260_loopbacks[] = {
6025         { 0x07, HDA_INPUT, 0 },
6026         { 0x07, HDA_INPUT, 1 },
6027         { 0x07, HDA_INPUT, 2 },
6028         { 0x07, HDA_INPUT, 3 },
6029         { 0x07, HDA_INPUT, 4 },
6030         { } /* end */
6031 };
6032 #endif
6033
6034 /*
6035  * ALC260 configurations
6036  */
6037 static const char *alc260_models[ALC260_MODEL_LAST] = {
6038         [ALC260_BASIC]          = "basic",
6039         [ALC260_HP]             = "hp",
6040         [ALC260_HP_3013]        = "hp-3013",
6041         [ALC260_HP_DC7600]      = "hp-dc7600",
6042         [ALC260_FUJITSU_S702X]  = "fujitsu",
6043         [ALC260_ACER]           = "acer",
6044         [ALC260_WILL]           = "will",
6045         [ALC260_REPLACER_672V]  = "replacer",
6046         [ALC260_FAVORIT100]     = "favorit100",
6047 #ifdef CONFIG_SND_DEBUG
6048         [ALC260_TEST]           = "test",
6049 #endif
6050         [ALC260_AUTO]           = "auto",
6051 };
6052
6053 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6054         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6055         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6056         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6057         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6058         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
6059         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6060         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6061         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6062         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6063         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6064         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6065         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6066         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6067         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6068         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6069         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6070         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6071         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6072         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6073         {}
6074 };
6075
6076 static struct alc_config_preset alc260_presets[] = {
6077         [ALC260_BASIC] = {
6078                 .mixers = { alc260_base_output_mixer,
6079                             alc260_input_mixer },
6080                 .init_verbs = { alc260_init_verbs },
6081                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6082                 .dac_nids = alc260_dac_nids,
6083                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6084                 .adc_nids = alc260_adc_nids,
6085                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6086                 .channel_mode = alc260_modes,
6087                 .input_mux = &alc260_capture_source,
6088         },
6089         [ALC260_HP] = {
6090                 .mixers = { alc260_hp_output_mixer,
6091                             alc260_input_mixer },
6092                 .init_verbs = { alc260_init_verbs,
6093                                 alc260_hp_unsol_verbs },
6094                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6095                 .dac_nids = alc260_dac_nids,
6096                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6097                 .adc_nids = alc260_adc_nids_alt,
6098                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6099                 .channel_mode = alc260_modes,
6100                 .input_mux = &alc260_capture_source,
6101                 .unsol_event = alc260_hp_unsol_event,
6102                 .init_hook = alc260_hp_automute,
6103         },
6104         [ALC260_HP_DC7600] = {
6105                 .mixers = { alc260_hp_dc7600_mixer,
6106                             alc260_input_mixer },
6107                 .init_verbs = { alc260_init_verbs,
6108                                 alc260_hp_dc7600_verbs },
6109                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6110                 .dac_nids = alc260_dac_nids,
6111                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6112                 .adc_nids = alc260_adc_nids_alt,
6113                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6114                 .channel_mode = alc260_modes,
6115                 .input_mux = &alc260_capture_source,
6116                 .unsol_event = alc260_hp_3012_unsol_event,
6117                 .init_hook = alc260_hp_3012_automute,
6118         },
6119         [ALC260_HP_3013] = {
6120                 .mixers = { alc260_hp_3013_mixer,
6121                             alc260_input_mixer },
6122                 .init_verbs = { alc260_hp_3013_init_verbs,
6123                                 alc260_hp_3013_unsol_verbs },
6124                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6125                 .dac_nids = alc260_dac_nids,
6126                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6127                 .adc_nids = alc260_adc_nids_alt,
6128                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6129                 .channel_mode = alc260_modes,
6130                 .input_mux = &alc260_capture_source,
6131                 .unsol_event = alc260_hp_3013_unsol_event,
6132                 .init_hook = alc260_hp_3013_automute,
6133         },
6134         [ALC260_FUJITSU_S702X] = {
6135                 .mixers = { alc260_fujitsu_mixer },
6136                 .init_verbs = { alc260_fujitsu_init_verbs },
6137                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6138                 .dac_nids = alc260_dac_nids,
6139                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6140                 .adc_nids = alc260_dual_adc_nids,
6141                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6142                 .channel_mode = alc260_modes,
6143                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6144                 .input_mux = alc260_fujitsu_capture_sources,
6145         },
6146         [ALC260_ACER] = {
6147                 .mixers = { alc260_acer_mixer },
6148                 .init_verbs = { alc260_acer_init_verbs },
6149                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6150                 .dac_nids = alc260_dac_nids,
6151                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6152                 .adc_nids = alc260_dual_adc_nids,
6153                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6154                 .channel_mode = alc260_modes,
6155                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6156                 .input_mux = alc260_acer_capture_sources,
6157         },
6158         [ALC260_FAVORIT100] = {
6159                 .mixers = { alc260_favorit100_mixer },
6160                 .init_verbs = { alc260_favorit100_init_verbs },
6161                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6162                 .dac_nids = alc260_dac_nids,
6163                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6164                 .adc_nids = alc260_dual_adc_nids,
6165                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6166                 .channel_mode = alc260_modes,
6167                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6168                 .input_mux = alc260_favorit100_capture_sources,
6169         },
6170         [ALC260_WILL] = {
6171                 .mixers = { alc260_will_mixer },
6172                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6173                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6174                 .dac_nids = alc260_dac_nids,
6175                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6176                 .adc_nids = alc260_adc_nids,
6177                 .dig_out_nid = ALC260_DIGOUT_NID,
6178                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6179                 .channel_mode = alc260_modes,
6180                 .input_mux = &alc260_capture_source,
6181         },
6182         [ALC260_REPLACER_672V] = {
6183                 .mixers = { alc260_replacer_672v_mixer },
6184                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6185                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6186                 .dac_nids = alc260_dac_nids,
6187                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6188                 .adc_nids = alc260_adc_nids,
6189                 .dig_out_nid = ALC260_DIGOUT_NID,
6190                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6191                 .channel_mode = alc260_modes,
6192                 .input_mux = &alc260_capture_source,
6193                 .unsol_event = alc260_replacer_672v_unsol_event,
6194                 .init_hook = alc260_replacer_672v_automute,
6195         },
6196 #ifdef CONFIG_SND_DEBUG
6197         [ALC260_TEST] = {
6198                 .mixers = { alc260_test_mixer },
6199                 .init_verbs = { alc260_test_init_verbs },
6200                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6201                 .dac_nids = alc260_test_dac_nids,
6202                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6203                 .adc_nids = alc260_test_adc_nids,
6204                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6205                 .channel_mode = alc260_modes,
6206                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6207                 .input_mux = alc260_test_capture_sources,
6208         },
6209 #endif
6210 };
6211
6212 static int patch_alc260(struct hda_codec *codec)
6213 {
6214         struct alc_spec *spec;
6215         int err, board_config;
6216
6217         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6218         if (spec == NULL)
6219                 return -ENOMEM;
6220
6221         codec->spec = spec;
6222
6223         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6224                                                   alc260_models,
6225                                                   alc260_cfg_tbl);
6226         if (board_config < 0) {
6227                 snd_printd(KERN_INFO "hda_codec: Unknown model for %s, "
6228                            "trying auto-probe from BIOS...\n",
6229                            codec->chip_name);
6230                 board_config = ALC260_AUTO;
6231         }
6232
6233         if (board_config == ALC260_AUTO) {
6234                 /* automatic parse from the BIOS config */
6235                 err = alc260_parse_auto_config(codec);
6236                 if (err < 0) {
6237                         alc_free(codec);
6238                         return err;
6239                 } else if (!err) {
6240                         printk(KERN_INFO
6241                                "hda_codec: Cannot set up configuration "
6242                                "from BIOS.  Using base mode...\n");
6243                         board_config = ALC260_BASIC;
6244                 }
6245         }
6246
6247         err = snd_hda_attach_beep_device(codec, 0x1);
6248         if (err < 0) {
6249                 alc_free(codec);
6250                 return err;
6251         }
6252
6253         if (board_config != ALC260_AUTO)
6254                 setup_preset(spec, &alc260_presets[board_config]);
6255
6256         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6257         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6258
6259         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6260         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6261
6262         if (!spec->adc_nids && spec->input_mux) {
6263                 /* check whether NID 0x04 is valid */
6264                 unsigned int wcap = get_wcaps(codec, 0x04);
6265                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
6266                 /* get type */
6267                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6268                         spec->adc_nids = alc260_adc_nids_alt;
6269                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6270                 } else {
6271                         spec->adc_nids = alc260_adc_nids;
6272                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6273                 }
6274         }
6275         set_capture_mixer(spec);
6276         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6277
6278         spec->vmaster_nid = 0x08;
6279
6280         codec->patch_ops = alc_patch_ops;
6281         if (board_config == ALC260_AUTO)
6282                 spec->init_hook = alc260_auto_init;
6283 #ifdef CONFIG_SND_HDA_POWER_SAVE
6284         if (!spec->loopback.amplist)
6285                 spec->loopback.amplist = alc260_loopbacks;
6286 #endif
6287         codec->proc_widget_hook = print_realtek_coef;
6288
6289         return 0;
6290 }
6291
6292
6293 /*
6294  * ALC882/883/885/888/889 support
6295  *
6296  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6297  * configuration.  Each pin widget can choose any input DACs and a mixer.
6298  * Each ADC is connected from a mixer of all inputs.  This makes possible
6299  * 6-channel independent captures.
6300  *
6301  * In addition, an independent DAC for the multi-playback (not used in this
6302  * driver yet).
6303  */
6304 #define ALC882_DIGOUT_NID       0x06
6305 #define ALC882_DIGIN_NID        0x0a
6306 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6307 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6308 #define ALC1200_DIGOUT_NID      0x10
6309
6310
6311 static struct hda_channel_mode alc882_ch_modes[1] = {
6312         { 8, NULL }
6313 };
6314
6315 /* DACs */
6316 static hda_nid_t alc882_dac_nids[4] = {
6317         /* front, rear, clfe, rear_surr */
6318         0x02, 0x03, 0x04, 0x05
6319 };
6320 #define alc883_dac_nids         alc882_dac_nids
6321
6322 /* ADCs */
6323 #define alc882_adc_nids         alc880_adc_nids
6324 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6325 #define alc883_adc_nids         alc882_adc_nids_alt
6326 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6327 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6328 #define alc889_adc_nids         alc880_adc_nids
6329
6330 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6331 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6332 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6333 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6334 #define alc889_capsrc_nids      alc882_capsrc_nids
6335
6336 /* input MUX */
6337 /* FIXME: should be a matrix-type input source selection */
6338
6339 static struct hda_input_mux alc882_capture_source = {
6340         .num_items = 4,
6341         .items = {
6342                 { "Mic", 0x0 },
6343                 { "Front Mic", 0x1 },
6344                 { "Line", 0x2 },
6345                 { "CD", 0x4 },
6346         },
6347 };
6348
6349 #define alc883_capture_source   alc882_capture_source
6350
6351 static struct hda_input_mux mb5_capture_source = {
6352         .num_items = 3,
6353         .items = {
6354                 { "Mic", 0x1 },
6355                 { "Line", 0x2 },
6356                 { "CD", 0x4 },
6357         },
6358 };
6359
6360 static struct hda_input_mux alc883_3stack_6ch_intel = {
6361         .num_items = 4,
6362         .items = {
6363                 { "Mic", 0x1 },
6364                 { "Front Mic", 0x0 },
6365                 { "Line", 0x2 },
6366                 { "CD", 0x4 },
6367         },
6368 };
6369
6370 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6371         .num_items = 2,
6372         .items = {
6373                 { "Mic", 0x1 },
6374                 { "Line", 0x2 },
6375         },
6376 };
6377
6378 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6379         .num_items = 4,
6380         .items = {
6381                 { "Mic", 0x0 },
6382                 { "iMic", 0x1 },
6383                 { "Line", 0x2 },
6384                 { "CD", 0x4 },
6385         },
6386 };
6387
6388 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6389         .num_items = 2,
6390         .items = {
6391                 { "Mic", 0x0 },
6392                 { "Int Mic", 0x1 },
6393         },
6394 };
6395
6396 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6397         .num_items = 3,
6398         .items = {
6399                 { "Mic", 0x0 },
6400                 { "Front Mic", 0x1 },
6401                 { "Line", 0x4 },
6402         },
6403 };
6404
6405 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6406         .num_items = 2,
6407         .items = {
6408                 { "Mic", 0x0 },
6409                 { "Line", 0x2 },
6410         },
6411 };
6412
6413 static struct hda_input_mux alc889A_mb31_capture_source = {
6414         .num_items = 2,
6415         .items = {
6416                 { "Mic", 0x0 },
6417                 /* Front Mic (0x01) unused */
6418                 { "Line", 0x2 },
6419                 /* Line 2 (0x03) unused */
6420                 /* CD (0x04) unsused? */
6421         },
6422 };
6423
6424 /*
6425  * 2ch mode
6426  */
6427 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6428         { 2, NULL }
6429 };
6430
6431 /*
6432  * 2ch mode
6433  */
6434 static struct hda_verb alc882_3ST_ch2_init[] = {
6435         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6436         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6437         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6438         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6439         { } /* end */
6440 };
6441
6442 /*
6443  * 4ch mode
6444  */
6445 static struct hda_verb alc882_3ST_ch4_init[] = {
6446         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6447         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6448         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6449         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6450         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6451         { } /* end */
6452 };
6453
6454 /*
6455  * 6ch mode
6456  */
6457 static struct hda_verb alc882_3ST_ch6_init[] = {
6458         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6459         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6460         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6461         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6462         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6463         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6464         { } /* end */
6465 };
6466
6467 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6468         { 2, alc882_3ST_ch2_init },
6469         { 4, alc882_3ST_ch4_init },
6470         { 6, alc882_3ST_ch6_init },
6471 };
6472
6473 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6474
6475 /*
6476  * 6ch mode
6477  */
6478 static struct hda_verb alc882_sixstack_ch6_init[] = {
6479         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6480         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6481         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6482         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6483         { } /* end */
6484 };
6485
6486 /*
6487  * 8ch mode
6488  */
6489 static struct hda_verb alc882_sixstack_ch8_init[] = {
6490         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6491         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6492         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6493         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6494         { } /* end */
6495 };
6496
6497 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6498         { 6, alc882_sixstack_ch6_init },
6499         { 8, alc882_sixstack_ch8_init },
6500 };
6501
6502 /*
6503  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6504  */
6505
6506 /*
6507  * 2ch mode
6508  */
6509 static struct hda_verb alc885_mbp_ch2_init[] = {
6510         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6511         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6512         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6513         { } /* end */
6514 };
6515
6516 /*
6517  * 6ch mode
6518  */
6519 static struct hda_verb alc885_mbp_ch6_init[] = {
6520         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6521         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6522         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6523         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6524         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6525         { } /* end */
6526 };
6527
6528 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6529         { 2, alc885_mbp_ch2_init },
6530         { 6, alc885_mbp_ch6_init },
6531 };
6532
6533 /*
6534  * 2ch
6535  * Speakers/Woofer/HP = Front
6536  * LineIn = Input
6537  */
6538 static struct hda_verb alc885_mb5_ch2_init[] = {
6539         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6540         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6541         { } /* end */
6542 };
6543
6544 /*
6545  * 6ch mode
6546  * Speakers/HP = Front
6547  * Woofer = LFE
6548  * LineIn = Surround
6549  */
6550 static struct hda_verb alc885_mb5_ch6_init[] = {
6551         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6552         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6553         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6554         { } /* end */
6555 };
6556
6557 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6558         { 2, alc885_mb5_ch2_init },
6559         { 6, alc885_mb5_ch6_init },
6560 };
6561
6562
6563 /*
6564  * 2ch mode
6565  */
6566 static struct hda_verb alc883_4ST_ch2_init[] = {
6567         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6568         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6569         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6570         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6571         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6572         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6573         { } /* end */
6574 };
6575
6576 /*
6577  * 4ch mode
6578  */
6579 static struct hda_verb alc883_4ST_ch4_init[] = {
6580         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6581         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6582         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6583         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6584         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6585         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6586         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6587         { } /* end */
6588 };
6589
6590 /*
6591  * 6ch mode
6592  */
6593 static struct hda_verb alc883_4ST_ch6_init[] = {
6594         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6595         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6596         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6597         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6598         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6599         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6600         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6601         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6602         { } /* end */
6603 };
6604
6605 /*
6606  * 8ch mode
6607  */
6608 static struct hda_verb alc883_4ST_ch8_init[] = {
6609         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6610         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6611         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6612         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6613         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6614         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6615         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6616         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6617         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6618         { } /* end */
6619 };
6620
6621 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6622         { 2, alc883_4ST_ch2_init },
6623         { 4, alc883_4ST_ch4_init },
6624         { 6, alc883_4ST_ch6_init },
6625         { 8, alc883_4ST_ch8_init },
6626 };
6627
6628
6629 /*
6630  * 2ch mode
6631  */
6632 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6633         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6634         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6635         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6636         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6637         { } /* end */
6638 };
6639
6640 /*
6641  * 4ch mode
6642  */
6643 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6644         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6645         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6646         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6647         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6648         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6649         { } /* end */
6650 };
6651
6652 /*
6653  * 6ch mode
6654  */
6655 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6656         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6657         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6658         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6659         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6660         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6661         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6662         { } /* end */
6663 };
6664
6665 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6666         { 2, alc883_3ST_ch2_intel_init },
6667         { 4, alc883_3ST_ch4_intel_init },
6668         { 6, alc883_3ST_ch6_intel_init },
6669 };
6670
6671 /*
6672  * 6ch mode
6673  */
6674 static struct hda_verb alc883_sixstack_ch6_init[] = {
6675         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6676         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6677         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6678         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6679         { } /* end */
6680 };
6681
6682 /*
6683  * 8ch mode
6684  */
6685 static struct hda_verb alc883_sixstack_ch8_init[] = {
6686         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6687         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6688         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6689         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6690         { } /* end */
6691 };
6692
6693 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6694         { 6, alc883_sixstack_ch6_init },
6695         { 8, alc883_sixstack_ch8_init },
6696 };
6697
6698
6699 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6700  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6701  */
6702 static struct snd_kcontrol_new alc882_base_mixer[] = {
6703         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6704         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6705         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6706         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6707         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6708         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6709         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6710         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6711         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6712         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6713         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6714         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6715         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6716         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6717         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6718         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6719         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6720         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6721         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6722         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6723         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6724         { } /* end */
6725 };
6726
6727 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6728         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6729         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6730         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6731         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6732         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6733         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6734         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6735         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6736         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6737         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6738         { } /* end */
6739 };
6740
6741 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
6742         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6743         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6744         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6745         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
6746         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
6747         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
6748         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
6749         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
6750         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6751         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6752         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6753         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6754         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
6755         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
6756         { } /* end */
6757 };
6758
6759 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6760         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6761         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6762         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6763         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6764         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6765         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6766         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6767         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6768         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6769         { } /* end */
6770 };
6771
6772 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6773         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6774         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6775         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6776         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6777         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6778         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6779         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6780         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6781         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6782         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6783         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6784         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6785         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6786         { } /* end */
6787 };
6788
6789 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6790  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6791  */
6792 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6793         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6794         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6796         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6797         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6798         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6799         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6800         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6801         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6802         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6805         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6806         { } /* end */
6807 };
6808
6809 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
6810         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6811         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6812         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6813         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6814         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6815         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6816         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6817         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6818         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6819         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6820         { } /* end */
6821 };
6822
6823 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
6824         {
6825                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
6826                 .name = "Channel Mode",
6827                 .info = alc_ch_mode_info,
6828                 .get = alc_ch_mode_get,
6829                 .put = alc_ch_mode_put,
6830         },
6831         { } /* end */
6832 };
6833
6834 static struct hda_verb alc882_base_init_verbs[] = {
6835         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6836         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6837         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6838         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6839         /* Rear mixer */
6840         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6841         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6842         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6843         /* CLFE mixer */
6844         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6845         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6846         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6847         /* Side mixer */
6848         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6849         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6850         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6851
6852         /* mute analog input loopbacks */
6853         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6854         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6855         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6856         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6857         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6858
6859         /* Front Pin: output 0 (0x0c) */
6860         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6861         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6862         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
6863         /* Rear Pin: output 1 (0x0d) */
6864         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6865         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6866         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6867         /* CLFE Pin: output 2 (0x0e) */
6868         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6869         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6870         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
6871         /* Side Pin: output 3 (0x0f) */
6872         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6873         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6874         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
6875         /* Mic (rear) pin: input vref at 80% */
6876         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6877         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6878         /* Front Mic pin: input vref at 80% */
6879         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6880         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6881         /* Line In pin: input */
6882         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6883         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6884         /* Line-2 In: Headphone output (output 0 - 0x0c) */
6885         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6886         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6887         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
6888         /* CD pin widget for input */
6889         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6890
6891         /* FIXME: use matrix-type input source selection */
6892         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6893         /* Input mixer2 */
6894         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6895         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6896         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6897         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6898         /* Input mixer3 */
6899         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6900         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6901         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6902         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6903         /* ADC2: mute amp left and right */
6904         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6905         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6906         /* ADC3: mute amp left and right */
6907         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6908         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6909
6910         { }
6911 };
6912
6913 static struct hda_verb alc882_adc1_init_verbs[] = {
6914         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6915         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6916         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6917         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6918         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6919         /* ADC1: mute amp left and right */
6920         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6921         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6922         { }
6923 };
6924
6925 static struct hda_verb alc882_eapd_verbs[] = {
6926         /* change to EAPD mode */
6927         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
6928         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
6929         { }
6930 };
6931
6932 #define alc883_init_verbs       alc882_base_init_verbs
6933
6934 /* Mac Pro test */
6935 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
6936         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6937         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6938         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
6939         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
6940         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
6941         /* FIXME: this looks suspicious...
6942         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
6943         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
6944         */
6945         { } /* end */
6946 };
6947
6948 static struct hda_verb alc882_macpro_init_verbs[] = {
6949         /* Front mixer: unmute input/output amp left and right (volume = 0) */
6950         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6951         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6952         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6953         /* Front Pin: output 0 (0x0c) */
6954         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6955         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6956         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
6957         /* Front Mic pin: input vref at 80% */
6958         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6959         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6960         /* Speaker:  output */
6961         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6962         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6963         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
6964         /* Headphone output (output 0 - 0x0c) */
6965         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6966         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6967         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
6968
6969         /* FIXME: use matrix-type input source selection */
6970         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
6971         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
6972         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6973         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6974         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6975         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6976         /* Input mixer2 */
6977         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6978         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6979         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6980         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6981         /* Input mixer3 */
6982         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6983         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6984         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6985         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6986         /* ADC1: mute amp left and right */
6987         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6988         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
6989         /* ADC2: mute amp left and right */
6990         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6991         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
6992         /* ADC3: mute amp left and right */
6993         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6994         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
6995
6996         { }
6997 };
6998
6999 /* Macbook 5,1 */
7000 static struct hda_verb alc885_mb5_init_verbs[] = {
7001         /* DACs */
7002         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7003         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7004         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7005         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7006         /* Front mixer */
7007         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7008         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7009         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7010         /* Surround mixer */
7011         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7012         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7013         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7014         /* LFE mixer */
7015         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7016         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7017         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7018         /* HP mixer */
7019         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7020         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7021         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7022         /* Front Pin (0x0c) */
7023         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7024         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7025         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7026         /* LFE Pin (0x0e) */
7027         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7028         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7029         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7030         /* HP Pin (0x0f) */
7031         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7032         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7033         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7034         /* Front Mic pin: input vref at 80% */
7035         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7036         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7037         /* Line In pin */
7038         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7039         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7040
7041         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7042         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7043         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7044         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7045         { }
7046 };
7047
7048 /* Macbook Pro rev3 */
7049 static struct hda_verb alc885_mbp3_init_verbs[] = {
7050         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7051         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7052         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7053         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7054         /* Rear mixer */
7055         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7056         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7057         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7058         /* Front Pin: output 0 (0x0c) */
7059         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7060         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7061         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7062         /* HP Pin: output 0 (0x0d) */
7063         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7064         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7065         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7066         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7067         /* Mic (rear) pin: input vref at 80% */
7068         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7069         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7070         /* Front Mic pin: input vref at 80% */
7071         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7072         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7073         /* Line In pin: use output 1 when in LineOut mode */
7074         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7075         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7076         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7077
7078         /* FIXME: use matrix-type input source selection */
7079         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7080         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7081         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7082         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7083         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7084         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7085         /* Input mixer2 */
7086         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7087         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7088         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7089         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7090         /* Input mixer3 */
7091         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7092         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7093         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7094         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7095         /* ADC1: mute amp left and right */
7096         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7097         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7098         /* ADC2: mute amp left and right */
7099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7100         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7101         /* ADC3: mute amp left and right */
7102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7103         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7104
7105         { }
7106 };
7107
7108 /* iMac 24 mixer. */
7109 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7110         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7111         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7112         { } /* end */
7113 };
7114
7115 /* iMac 24 init verbs. */
7116 static struct hda_verb alc885_imac24_init_verbs[] = {
7117         /* Internal speakers: output 0 (0x0c) */
7118         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7119         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7120         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7121         /* Internal speakers: output 0 (0x0c) */
7122         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7123         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7124         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7125         /* Headphone: output 0 (0x0c) */
7126         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7127         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7128         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7129         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7130         /* Front Mic: input vref at 80% */
7131         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7132         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7133         { }
7134 };
7135
7136 /* Toggle speaker-output according to the hp-jack state */
7137 static void alc885_imac24_automute_init_hook(struct hda_codec *codec)
7138 {
7139         struct alc_spec *spec = codec->spec;
7140
7141         spec->autocfg.hp_pins[0] = 0x14;
7142         spec->autocfg.speaker_pins[0] = 0x18;
7143         spec->autocfg.speaker_pins[1] = 0x1a;
7144         alc_automute_amp(codec);
7145 }
7146
7147 static void alc885_mbp3_init_hook(struct hda_codec *codec)
7148 {
7149         struct alc_spec *spec = codec->spec;
7150
7151         spec->autocfg.hp_pins[0] = 0x15;
7152         spec->autocfg.speaker_pins[0] = 0x14;
7153         alc_automute_amp(codec);
7154 }
7155
7156
7157 static struct hda_verb alc882_targa_verbs[] = {
7158         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7159         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7160
7161         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7162         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7163
7164         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7165         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7166         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7167
7168         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7169         { } /* end */
7170 };
7171
7172 /* toggle speaker-output according to the hp-jack state */
7173 static void alc882_targa_automute(struct hda_codec *codec)
7174 {
7175         struct alc_spec *spec = codec->spec;
7176         alc_automute_amp(codec);
7177         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7178                                   spec->jack_present ? 1 : 3);
7179 }
7180
7181 static void alc882_targa_init_hook(struct hda_codec *codec)
7182 {
7183         struct alc_spec *spec = codec->spec;
7184
7185         spec->autocfg.hp_pins[0] = 0x14;
7186         spec->autocfg.speaker_pins[0] = 0x1b;
7187         alc882_targa_automute(codec);
7188 }
7189
7190 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7191 {
7192         if ((res >> 26) == ALC880_HP_EVENT)
7193                 alc882_targa_automute(codec);
7194 }
7195
7196 static struct hda_verb alc882_asus_a7j_verbs[] = {
7197         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7198         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7199
7200         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7201         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7202         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7203
7204         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7205         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7206         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7207
7208         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7209         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7210         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7211         { } /* end */
7212 };
7213
7214 static struct hda_verb alc882_asus_a7m_verbs[] = {
7215         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7216         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7217
7218         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7219         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7220         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7221
7222         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7223         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7224         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7225
7226         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7227         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7228         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7229         { } /* end */
7230 };
7231
7232 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7233 {
7234         unsigned int gpiostate, gpiomask, gpiodir;
7235
7236         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7237                                        AC_VERB_GET_GPIO_DATA, 0);
7238
7239         if (!muted)
7240                 gpiostate |= (1 << pin);
7241         else
7242                 gpiostate &= ~(1 << pin);
7243
7244         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7245                                       AC_VERB_GET_GPIO_MASK, 0);
7246         gpiomask |= (1 << pin);
7247
7248         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7249                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7250         gpiodir |= (1 << pin);
7251
7252
7253         snd_hda_codec_write(codec, codec->afg, 0,
7254                             AC_VERB_SET_GPIO_MASK, gpiomask);
7255         snd_hda_codec_write(codec, codec->afg, 0,
7256                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7257
7258         msleep(1);
7259
7260         snd_hda_codec_write(codec, codec->afg, 0,
7261                             AC_VERB_SET_GPIO_DATA, gpiostate);
7262 }
7263
7264 /* set up GPIO at initialization */
7265 static void alc885_macpro_init_hook(struct hda_codec *codec)
7266 {
7267         alc882_gpio_mute(codec, 0, 0);
7268         alc882_gpio_mute(codec, 1, 0);
7269 }
7270
7271 /* set up GPIO and update auto-muting at initialization */
7272 static void alc885_imac24_init_hook(struct hda_codec *codec)
7273 {
7274         alc885_macpro_init_hook(codec);
7275         alc885_imac24_automute_init_hook(codec);
7276 }
7277
7278 /*
7279  * generic initialization of ADC, input mixers and output mixers
7280  */
7281 static struct hda_verb alc883_auto_init_verbs[] = {
7282         /*
7283          * Unmute ADC0-2 and set the default input to mic-in
7284          */
7285         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7286         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7287         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7288         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7289
7290         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7291          * mixer widget
7292          * Note: PASD motherboards uses the Line In 2 as the input for
7293          * front panel mic (mic 2)
7294          */
7295         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7296         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7297         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7298         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7299         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7300         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7301
7302         /*
7303          * Set up output mixers (0x0c - 0x0f)
7304          */
7305         /* set vol=0 to output mixers */
7306         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7307         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7308         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7309         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7310         /* set up input amps for analog loopback */
7311         /* Amp Indices: DAC = 0, mixer = 1 */
7312         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7313         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7314         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7315         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7316         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7317         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7318         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7319         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7320         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7321         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7322
7323         /* FIXME: use matrix-type input source selection */
7324         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7325         /* Input mixer2 */
7326         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7327         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7328         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7330         /* Input mixer3 */
7331         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7332         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7333         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7334         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7335
7336         { }
7337 };
7338
7339 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7340 static struct hda_verb alc889A_mb31_ch2_init[] = {
7341         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7342         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7343         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7344         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7345         { } /* end */
7346 };
7347
7348 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7349 static struct hda_verb alc889A_mb31_ch4_init[] = {
7350         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7351         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7352         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7353         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7354         { } /* end */
7355 };
7356
7357 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7358 static struct hda_verb alc889A_mb31_ch5_init[] = {
7359         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7360         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7361         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7362         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7363         { } /* end */
7364 };
7365
7366 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7367 static struct hda_verb alc889A_mb31_ch6_init[] = {
7368         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7369         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7370         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7371         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7372         { } /* end */
7373 };
7374
7375 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7376         { 2, alc889A_mb31_ch2_init },
7377         { 4, alc889A_mb31_ch4_init },
7378         { 5, alc889A_mb31_ch5_init },
7379         { 6, alc889A_mb31_ch6_init },
7380 };
7381
7382 static struct hda_verb alc883_medion_eapd_verbs[] = {
7383         /* eanable EAPD on medion laptop */
7384         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7385         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7386         { }
7387 };
7388
7389 #define alc883_base_mixer       alc882_base_mixer
7390
7391 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7392         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7393         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7394         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7395         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7396         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7397         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7398         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7399         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7400         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7401         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7402         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7403         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7404         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7405         { } /* end */
7406 };
7407
7408 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7409         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7410         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7411         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7412         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7413         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7414         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7415         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7416         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7417         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7418         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7419         { } /* end */
7420 };
7421
7422 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7423         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7424         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7425         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7426         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7427         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7428         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7429         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7430         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7431         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7432         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7433         { } /* end */
7434 };
7435
7436 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7437         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7438         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7439         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7440         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7441         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7442         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7443         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7444         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7445         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7446         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7447         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7448         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7449         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7450         { } /* end */
7451 };
7452
7453 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7454         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7455         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7456         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7457         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7458         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7459         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7460         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7461         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7462         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7463         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7464         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7465         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7466         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7467         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7468         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7469         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7470         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7471         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7472         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7473         { } /* end */
7474 };
7475
7476 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7477         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7478         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7479         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7480         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7481         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7482                               HDA_OUTPUT),
7483         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7484         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7485         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7486         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7487         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7488         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7489         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7490         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7491         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7492         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7493         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7494         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7495         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7496         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7497         { } /* end */
7498 };
7499
7500 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7501         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7502         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7503         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7504         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7505         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7506         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7507         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7508         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7509         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7510         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7511         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7512         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7513         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7515         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7516         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7517         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7518         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7519         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7520         { } /* end */
7521 };
7522
7523 static struct snd_kcontrol_new alc883_targa_mixer[] = {
7524         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7525         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7526         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7527         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7528         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7529         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7530         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7531         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7532         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7533         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7534         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7535         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7536         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7537         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7538         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7539         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7540         { } /* end */
7541 };
7542
7543 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
7544         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7545         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7546         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7547         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7548         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7549         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7550         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7551         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7552         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7553         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7554         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7555         { } /* end */
7556 };
7557
7558 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7559         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7560         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7561         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7562         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7563         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7564         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7565         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7566         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7567         { } /* end */
7568 };
7569
7570 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7571         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7572         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7573         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7574         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7575         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7576         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7577         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7578         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7579         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7580         { } /* end */
7581 };
7582
7583 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7584         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7585         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7586         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7587         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7588         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7589         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7590         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7591         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7592         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7593         { } /* end */
7594 };
7595
7596 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7597         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7598         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7599         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7600         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7601         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7602         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7603         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7604         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7605         { } /* end */
7606 };
7607
7608 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
7609         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7610         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7611         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7612         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
7613         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7614         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7615         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7616         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7617         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7618         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7619         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7620         { } /* end */
7621 };
7622
7623 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7624         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7625         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7626         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7627         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7628         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7629                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7630         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7631         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7632         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7633         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7634         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7635         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7636         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7637         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7638         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7639         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7640         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7641         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7642         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7643         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7644         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7645         { } /* end */
7646 };
7647
7648 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
7649         /* Output mixers */
7650         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7651         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7652         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7653         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7654         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
7655                 HDA_OUTPUT),
7656         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
7657         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
7658         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
7659         /* Output switches */
7660         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
7661         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
7662         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
7663         /* Boost mixers */
7664         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7665         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7666         /* Input mixers */
7667         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7668         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7669         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7670         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7671         { } /* end */
7672 };
7673
7674 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
7675         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7676         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7677         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7678         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7679         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7680         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7681         { } /* end */
7682 };
7683
7684 static struct hda_bind_ctls alc883_bind_cap_vol = {
7685         .ops = &snd_hda_bind_vol,
7686         .values = {
7687                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7688                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7689                 0
7690         },
7691 };
7692
7693 static struct hda_bind_ctls alc883_bind_cap_switch = {
7694         .ops = &snd_hda_bind_sw,
7695         .values = {
7696                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
7697                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
7698                 0
7699         },
7700 };
7701
7702 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
7703         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7704         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7705         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7706         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7707         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7708         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7709         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7710         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7711         { } /* end */
7712 };
7713
7714 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
7715         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
7716         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
7717         {
7718                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7719                 /* .name = "Capture Source", */
7720                 .name = "Input Source",
7721                 .count = 1,
7722                 .info = alc_mux_enum_info,
7723                 .get = alc_mux_enum_get,
7724                 .put = alc_mux_enum_put,
7725         },
7726         { } /* end */
7727 };
7728
7729 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
7730         {
7731                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7732                 .name = "Channel Mode",
7733                 .info = alc_ch_mode_info,
7734                 .get = alc_ch_mode_get,
7735                 .put = alc_ch_mode_put,
7736         },
7737         { } /* end */
7738 };
7739
7740 /* toggle speaker-output according to the hp-jack state */
7741 static void alc883_mitac_init_hook(struct hda_codec *codec)
7742 {
7743         struct alc_spec *spec = codec->spec;
7744
7745         spec->autocfg.hp_pins[0] = 0x15;
7746         spec->autocfg.speaker_pins[0] = 0x14;
7747         spec->autocfg.speaker_pins[1] = 0x17;
7748         alc_automute_amp(codec);
7749 }
7750
7751 /* auto-toggle front mic */
7752 /*
7753 static void alc883_mitac_mic_automute(struct hda_codec *codec)
7754 {
7755         unsigned int present;
7756         unsigned char bits;
7757
7758         present = snd_hda_codec_read(codec, 0x18, 0,
7759                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7760         bits = present ? HDA_AMP_MUTE : 0;
7761         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
7762 }
7763 */
7764
7765 static struct hda_verb alc883_mitac_verbs[] = {
7766         /* HP */
7767         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7768         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7769         /* Subwoofer */
7770         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
7771         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7772
7773         /* enable unsolicited event */
7774         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7775         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
7776
7777         { } /* end */
7778 };
7779
7780 static struct hda_verb alc883_clevo_m720_verbs[] = {
7781         /* HP */
7782         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7783         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7784         /* Int speaker */
7785         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
7786         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7787
7788         /* enable unsolicited event */
7789         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7790         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
7791
7792         { } /* end */
7793 };
7794
7795 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
7796         /* HP */
7797         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7798         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7799         /* Subwoofer */
7800         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7801         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7802
7803         /* enable unsolicited event */
7804         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7805
7806         { } /* end */
7807 };
7808
7809 static struct hda_verb alc883_targa_verbs[] = {
7810         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7811         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7812
7813         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7814         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7815
7816 /* Connect Line-Out side jack (SPDIF) to Side */
7817         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7818         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7819         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7820 /* Connect Mic jack to CLFE */
7821         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7822         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7823         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
7824 /* Connect Line-in jack to Surround */
7825         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7826         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7827         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7828 /* Connect HP out jack to Front */
7829         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7830         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7831         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7832
7833         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7834
7835         { } /* end */
7836 };
7837
7838 static struct hda_verb alc883_lenovo_101e_verbs[] = {
7839         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7840         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
7841         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
7842         { } /* end */
7843 };
7844
7845 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
7846         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7847         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7848         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7849         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7850         { } /* end */
7851 };
7852
7853 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
7854         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7855         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7856         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7857         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
7858         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
7859         { } /* end */
7860 };
7861
7862 static struct hda_verb alc883_haier_w66_verbs[] = {
7863         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7864         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7865
7866         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7867
7868         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7869         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7870         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7871         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7872         { } /* end */
7873 };
7874
7875 static struct hda_verb alc888_lenovo_sky_verbs[] = {
7876         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7877         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7878         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7879         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7880         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7881         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7882         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7883         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7884         { } /* end */
7885 };
7886
7887 static struct hda_verb alc888_6st_dell_verbs[] = {
7888         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7889         { }
7890 };
7891
7892 static struct hda_verb alc883_vaiott_verbs[] = {
7893         /* HP */
7894         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7895         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7896
7897         /* enable unsolicited event */
7898         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7899
7900         { } /* end */
7901 };
7902
7903 static void alc888_3st_hp_init_hook(struct hda_codec *codec)
7904 {
7905         struct alc_spec *spec = codec->spec;
7906
7907         spec->autocfg.hp_pins[0] = 0x1b;
7908         spec->autocfg.speaker_pins[0] = 0x14;
7909         spec->autocfg.speaker_pins[1] = 0x16;
7910         spec->autocfg.speaker_pins[2] = 0x18;
7911         alc_automute_amp(codec);
7912 }
7913
7914 static struct hda_verb alc888_3st_hp_verbs[] = {
7915         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
7916         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
7917         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
7918         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7919         { } /* end */
7920 };
7921
7922 /*
7923  * 2ch mode
7924  */
7925 static struct hda_verb alc888_3st_hp_2ch_init[] = {
7926         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7927         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7928         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7929         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7930         { } /* end */
7931 };
7932
7933 /*
7934  * 4ch mode
7935  */
7936 static struct hda_verb alc888_3st_hp_4ch_init[] = {
7937         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7938         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7939         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7940         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7941         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
7942         { } /* end */
7943 };
7944
7945 /*
7946  * 6ch mode
7947  */
7948 static struct hda_verb alc888_3st_hp_6ch_init[] = {
7949         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7950         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7951         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7952         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7953         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7954         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
7955         { } /* end */
7956 };
7957
7958 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
7959         { 2, alc888_3st_hp_2ch_init },
7960         { 4, alc888_3st_hp_4ch_init },
7961         { 6, alc888_3st_hp_6ch_init },
7962 };
7963
7964 /* toggle front-jack and RCA according to the hp-jack state */
7965 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
7966 {
7967         unsigned int present;
7968
7969         present = snd_hda_codec_read(codec, 0x1b, 0,
7970                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7971         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
7972                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7973         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7974                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7975 }
7976
7977 /* toggle RCA according to the front-jack state */
7978 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
7979 {
7980         unsigned int present;
7981
7982         present = snd_hda_codec_read(codec, 0x14, 0,
7983                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7984         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7985                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7986 }
7987
7988 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
7989                                              unsigned int res)
7990 {
7991         if ((res >> 26) == ALC880_HP_EVENT)
7992                 alc888_lenovo_ms7195_front_automute(codec);
7993         if ((res >> 26) == ALC880_FRONT_EVENT)
7994                 alc888_lenovo_ms7195_rca_automute(codec);
7995 }
7996
7997 static struct hda_verb alc883_medion_md2_verbs[] = {
7998         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7999         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8000
8001         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8002
8003         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8004         { } /* end */
8005 };
8006
8007 /* toggle speaker-output according to the hp-jack state */
8008 static void alc883_medion_md2_init_hook(struct hda_codec *codec)
8009 {
8010         struct alc_spec *spec = codec->spec;
8011
8012         spec->autocfg.hp_pins[0] = 0x14;
8013         spec->autocfg.speaker_pins[0] = 0x15;
8014         alc_automute_amp(codec);
8015 }
8016
8017 /* toggle speaker-output according to the hp-jack state */
8018 #define alc883_targa_init_hook          alc882_targa_init_hook
8019 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8020
8021 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8022 {
8023         unsigned int present;
8024
8025         present = snd_hda_codec_read(codec, 0x18, 0,
8026                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8027         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8028                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8029 }
8030
8031 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8032 {
8033         struct alc_spec *spec = codec->spec;
8034
8035         spec->autocfg.hp_pins[0] = 0x15;
8036         spec->autocfg.speaker_pins[0] = 0x14;
8037         alc_automute_amp(codec);
8038         alc883_clevo_m720_mic_automute(codec);
8039 }
8040
8041 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8042                                            unsigned int res)
8043 {
8044         switch (res >> 26) {
8045         case ALC880_MIC_EVENT:
8046                 alc883_clevo_m720_mic_automute(codec);
8047                 break;
8048         default:
8049                 alc_automute_amp_unsol_event(codec, res);
8050                 break;
8051         }
8052 }
8053
8054 /* toggle speaker-output according to the hp-jack state */
8055 static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
8056 {
8057         struct alc_spec *spec = codec->spec;
8058
8059         spec->autocfg.hp_pins[0] = 0x14;
8060         spec->autocfg.speaker_pins[0] = 0x15;
8061         alc_automute_amp(codec);
8062 }
8063
8064 static void alc883_haier_w66_init_hook(struct hda_codec *codec)
8065 {
8066         struct alc_spec *spec = codec->spec;
8067
8068         spec->autocfg.hp_pins[0] = 0x1b;
8069         spec->autocfg.speaker_pins[0] = 0x14;
8070         alc_automute_amp(codec);
8071 }
8072
8073 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8074 {
8075         unsigned int present;
8076         unsigned char bits;
8077
8078         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8079                 & AC_PINSENSE_PRESENCE;
8080         bits = present ? HDA_AMP_MUTE : 0;
8081         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8082                                  HDA_AMP_MUTE, bits);
8083 }
8084
8085 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8086 {
8087         unsigned int present;
8088         unsigned char bits;
8089
8090         present = snd_hda_codec_read(codec, 0x1b, 0,
8091                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8092         bits = present ? HDA_AMP_MUTE : 0;
8093         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8094                                  HDA_AMP_MUTE, bits);
8095         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8096                                  HDA_AMP_MUTE, bits);
8097 }
8098
8099 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8100                                            unsigned int res)
8101 {
8102         if ((res >> 26) == ALC880_HP_EVENT)
8103                 alc883_lenovo_101e_all_automute(codec);
8104         if ((res >> 26) == ALC880_FRONT_EVENT)
8105                 alc883_lenovo_101e_ispeaker_automute(codec);
8106 }
8107
8108 /* toggle speaker-output according to the hp-jack state */
8109 static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
8110 {
8111         struct alc_spec *spec = codec->spec;
8112
8113         spec->autocfg.hp_pins[0] = 0x14;
8114         spec->autocfg.speaker_pins[0] = 0x15;
8115         spec->autocfg.speaker_pins[1] = 0x16;
8116         alc_automute_amp(codec);
8117 }
8118
8119 static struct hda_verb alc883_acer_eapd_verbs[] = {
8120         /* HP Pin: output 0 (0x0c) */
8121         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8122         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8123         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8124         /* Front Pin: output 0 (0x0c) */
8125         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8126         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8127         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8128         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8129         /* eanable EAPD on medion laptop */
8130         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8131         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8132         /* enable unsolicited event */
8133         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8134         { }
8135 };
8136
8137 static void alc888_6st_dell_init_hook(struct hda_codec *codec)
8138 {
8139         struct alc_spec *spec = codec->spec;
8140
8141         spec->autocfg.hp_pins[0] = 0x1b;
8142         spec->autocfg.speaker_pins[0] = 0x14;
8143         spec->autocfg.speaker_pins[1] = 0x15;
8144         spec->autocfg.speaker_pins[2] = 0x16;
8145         spec->autocfg.speaker_pins[3] = 0x17;
8146         alc_automute_amp(codec);
8147 }
8148
8149 static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
8150 {
8151         struct alc_spec *spec = codec->spec;
8152
8153         spec->autocfg.hp_pins[0] = 0x1b;
8154         spec->autocfg.speaker_pins[0] = 0x14;
8155         spec->autocfg.speaker_pins[1] = 0x15;
8156         spec->autocfg.speaker_pins[2] = 0x16;
8157         spec->autocfg.speaker_pins[3] = 0x17;
8158         spec->autocfg.speaker_pins[4] = 0x1a;
8159         alc_automute_amp(codec);
8160 }
8161
8162 static void alc883_vaiott_init_hook(struct hda_codec *codec)
8163 {
8164         struct alc_spec *spec = codec->spec;
8165
8166         spec->autocfg.hp_pins[0] = 0x15;
8167         spec->autocfg.speaker_pins[0] = 0x14;
8168         spec->autocfg.speaker_pins[1] = 0x17;
8169         alc_automute_amp(codec);
8170 }
8171
8172 static struct hda_verb alc888_asus_m90v_verbs[] = {
8173         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8174         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8175         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8176         /* enable unsolicited event */
8177         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8178         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8179         { } /* end */
8180 };
8181
8182 static void alc883_nb_mic_automute(struct hda_codec *codec)
8183 {
8184         unsigned int present;
8185
8186         present = snd_hda_codec_read(codec, 0x18, 0,
8187                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8188         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8189                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8190         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8191                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8192 }
8193
8194 static void alc883_M90V_init_hook(struct hda_codec *codec)
8195 {
8196         struct alc_spec *spec = codec->spec;
8197
8198         spec->autocfg.hp_pins[0] = 0x1b;
8199         spec->autocfg.speaker_pins[0] = 0x14;
8200         spec->autocfg.speaker_pins[1] = 0x15;
8201         spec->autocfg.speaker_pins[2] = 0x16;
8202         alc_automute_pin(codec);
8203 }
8204
8205 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8206                                            unsigned int res)
8207 {
8208         switch (res >> 26) {
8209         case ALC880_MIC_EVENT:
8210                 alc883_nb_mic_automute(codec);
8211                 break;
8212         default:
8213                 alc_sku_unsol_event(codec, res);
8214                 break;
8215         }
8216 }
8217
8218 static void alc883_mode2_inithook(struct hda_codec *codec)
8219 {
8220         alc883_M90V_init_hook(codec);
8221         alc883_nb_mic_automute(codec);
8222 }
8223
8224 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8225         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8226         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8227         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8228         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8229         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8230         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8231         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8232         /* enable unsolicited event */
8233         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8234         { } /* end */
8235 };
8236
8237 static void alc883_eee1601_inithook(struct hda_codec *codec)
8238 {
8239         struct alc_spec *spec = codec->spec;
8240
8241         spec->autocfg.hp_pins[0] = 0x14;
8242         spec->autocfg.speaker_pins[0] = 0x1b;
8243         alc_automute_pin(codec);
8244 }
8245
8246 static struct hda_verb alc889A_mb31_verbs[] = {
8247         /* Init rear pin (used as headphone output) */
8248         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8249         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8250         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8251         /* Init line pin (used as output in 4ch and 6ch mode) */
8252         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8253         /* Init line 2 pin (used as headphone out by default) */
8254         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8255         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8256         { } /* end */
8257 };
8258
8259 /* Mute speakers according to the headphone jack state */
8260 static void alc889A_mb31_automute(struct hda_codec *codec)
8261 {
8262         unsigned int present;
8263
8264         /* Mute only in 2ch or 4ch mode */
8265         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8266             == 0x00) {
8267                 present = snd_hda_codec_read(codec, 0x15, 0,
8268                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8269                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8270                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8271                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8272                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8273         }
8274 }
8275
8276 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8277 {
8278         if ((res >> 26) == ALC880_HP_EVENT)
8279                 alc889A_mb31_automute(codec);
8280 }
8281
8282
8283 #ifdef CONFIG_SND_HDA_POWER_SAVE
8284 #define alc882_loopbacks        alc880_loopbacks
8285 #endif
8286
8287 /* pcm configuration: identical with ALC880 */
8288 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8289 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8290 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8291 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8292
8293 static hda_nid_t alc883_slave_dig_outs[] = {
8294         ALC1200_DIGOUT_NID, 0,
8295 };
8296
8297 static hda_nid_t alc1200_slave_dig_outs[] = {
8298         ALC883_DIGOUT_NID, 0,
8299 };
8300
8301 /*
8302  * configuration and preset
8303  */
8304 static const char *alc882_models[ALC882_MODEL_LAST] = {
8305         [ALC882_3ST_DIG]        = "3stack-dig",
8306         [ALC882_6ST_DIG]        = "6stack-dig",
8307         [ALC882_ARIMA]          = "arima",
8308         [ALC882_W2JC]           = "w2jc",
8309         [ALC882_TARGA]          = "targa",
8310         [ALC882_ASUS_A7J]       = "asus-a7j",
8311         [ALC882_ASUS_A7M]       = "asus-a7m",
8312         [ALC885_MACPRO]         = "macpro",
8313         [ALC885_MB5]            = "mb5",
8314         [ALC885_MBP3]           = "mbp3",
8315         [ALC885_IMAC24]         = "imac24",
8316         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8317         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8318         [ALC883_3ST_6ch]        = "3stack-6ch",
8319         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8320         [ALC883_TARGA_DIG]      = "targa-dig",
8321         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8322         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8323         [ALC883_ACER]           = "acer",
8324         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8325         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8326         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8327         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8328         [ALC883_MEDION]         = "medion",
8329         [ALC883_MEDION_MD2]     = "medion-md2",
8330         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8331         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8332         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8333         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8334         [ALC888_LENOVO_SKY] = "lenovo-sky",
8335         [ALC883_HAIER_W66]      = "haier-w66",
8336         [ALC888_3ST_HP]         = "3stack-hp",
8337         [ALC888_6ST_DELL]       = "6stack-dell",
8338         [ALC883_MITAC]          = "mitac",
8339         [ALC883_CLEVO_M720]     = "clevo-m720",
8340         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8341         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8342         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8343         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8344         [ALC889A_MB31]          = "mb31",
8345         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8346         [ALC882_AUTO]           = "auto",
8347 };
8348
8349 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8350         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8351
8352         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8353         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8354         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8355         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8356         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8357         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8358         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8359                 ALC888_ACER_ASPIRE_4930G),
8360         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8361                 ALC888_ACER_ASPIRE_4930G),
8362         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8363                 ALC888_ACER_ASPIRE_8930G),
8364         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8365                 ALC888_ACER_ASPIRE_8930G),
8366         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8367         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8368         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8369                 ALC888_ACER_ASPIRE_6530G),
8370         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8371                 ALC888_ACER_ASPIRE_6530G),
8372         /* default Acer -- disabled as it causes more problems.
8373          *    model=auto should work fine now
8374          */
8375         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8376
8377         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8378
8379         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8380         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8381         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8382         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8383         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8384         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8385
8386         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8387         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8388         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8389         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8390         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8391         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8392         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8393         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8394         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8395         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8396         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8397
8398         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8399         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8400         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8401         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8402         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8403         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8404         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8405         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8406         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8407
8408         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8409         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8410         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8411         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8412         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8413         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8414         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8415         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8416         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8417         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8418         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8419         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8420         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8421         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8422         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8423         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8424         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8425         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8426         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8427         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8428         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8429         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8430         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8431         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8432         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8433         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8434         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8435         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8436         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8437
8438         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8439         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8440         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8441         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8442         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8443         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
8444         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8445         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8446                       ALC883_FUJITSU_PI2515),
8447         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8448                 ALC888_FUJITSU_XA3530),
8449         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8450         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8451         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8452         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8453         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8454         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8455         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8456         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8457         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8458
8459         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8460         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8461         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8462         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC883_3ST_6ch_INTEL),
8463         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8464
8465         {}
8466 };
8467
8468 /* codec SSID table for Intel Mac */
8469 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
8470         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
8471         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
8472         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
8473         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
8474         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
8475         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
8476         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
8477         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
8478         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
8479         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
8480         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
8481         /* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
8482          * no perfect solution yet
8483          */
8484         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
8485         {} /* terminator */
8486 };
8487
8488 static struct alc_config_preset alc882_presets[] = {
8489         [ALC882_3ST_DIG] = {
8490                 .mixers = { alc882_base_mixer },
8491                 .init_verbs = { alc882_base_init_verbs,
8492                                 alc882_adc1_init_verbs },
8493                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8494                 .dac_nids = alc882_dac_nids,
8495                 .dig_out_nid = ALC882_DIGOUT_NID,
8496                 .dig_in_nid = ALC882_DIGIN_NID,
8497                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8498                 .channel_mode = alc882_ch_modes,
8499                 .need_dac_fix = 1,
8500                 .input_mux = &alc882_capture_source,
8501         },
8502         [ALC882_6ST_DIG] = {
8503                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8504                 .init_verbs = { alc882_base_init_verbs,
8505                                 alc882_adc1_init_verbs },
8506                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8507                 .dac_nids = alc882_dac_nids,
8508                 .dig_out_nid = ALC882_DIGOUT_NID,
8509                 .dig_in_nid = ALC882_DIGIN_NID,
8510                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8511                 .channel_mode = alc882_sixstack_modes,
8512                 .input_mux = &alc882_capture_source,
8513         },
8514         [ALC882_ARIMA] = {
8515                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8516                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8517                                 alc882_eapd_verbs },
8518                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8519                 .dac_nids = alc882_dac_nids,
8520                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8521                 .channel_mode = alc882_sixstack_modes,
8522                 .input_mux = &alc882_capture_source,
8523         },
8524         [ALC882_W2JC] = {
8525                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
8526                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8527                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
8528                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8529                 .dac_nids = alc882_dac_nids,
8530                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8531                 .channel_mode = alc880_threestack_modes,
8532                 .need_dac_fix = 1,
8533                 .input_mux = &alc882_capture_source,
8534                 .dig_out_nid = ALC882_DIGOUT_NID,
8535         },
8536         [ALC885_MBP3] = {
8537                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
8538                 .init_verbs = { alc885_mbp3_init_verbs,
8539                                 alc880_gpio1_init_verbs },
8540                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8541                 .dac_nids = alc882_dac_nids,
8542                 .channel_mode = alc885_mbp_6ch_modes,
8543                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
8544                 .input_mux = &alc882_capture_source,
8545                 .dig_out_nid = ALC882_DIGOUT_NID,
8546                 .dig_in_nid = ALC882_DIGIN_NID,
8547                 .unsol_event = alc_automute_amp_unsol_event,
8548                 .init_hook = alc885_mbp3_init_hook,
8549         },
8550         [ALC885_MB5] = {
8551                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
8552                 .init_verbs = { alc885_mb5_init_verbs,
8553                                 alc880_gpio1_init_verbs },
8554                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8555                 .dac_nids = alc882_dac_nids,
8556                 .channel_mode = alc885_mb5_6ch_modes,
8557                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
8558                 .input_mux = &mb5_capture_source,
8559                 .dig_out_nid = ALC882_DIGOUT_NID,
8560                 .dig_in_nid = ALC882_DIGIN_NID,
8561         },
8562         [ALC885_MACPRO] = {
8563                 .mixers = { alc882_macpro_mixer },
8564                 .init_verbs = { alc882_macpro_init_verbs },
8565                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8566                 .dac_nids = alc882_dac_nids,
8567                 .dig_out_nid = ALC882_DIGOUT_NID,
8568                 .dig_in_nid = ALC882_DIGIN_NID,
8569                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8570                 .channel_mode = alc882_ch_modes,
8571                 .input_mux = &alc882_capture_source,
8572                 .init_hook = alc885_macpro_init_hook,
8573         },
8574         [ALC885_IMAC24] = {
8575                 .mixers = { alc885_imac24_mixer },
8576                 .init_verbs = { alc885_imac24_init_verbs },
8577                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8578                 .dac_nids = alc882_dac_nids,
8579                 .dig_out_nid = ALC882_DIGOUT_NID,
8580                 .dig_in_nid = ALC882_DIGIN_NID,
8581                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8582                 .channel_mode = alc882_ch_modes,
8583                 .input_mux = &alc882_capture_source,
8584                 .unsol_event = alc_automute_amp_unsol_event,
8585                 .init_hook = alc885_imac24_init_hook,
8586         },
8587         [ALC882_TARGA] = {
8588                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
8589                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8590                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
8591                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8592                 .dac_nids = alc882_dac_nids,
8593                 .dig_out_nid = ALC882_DIGOUT_NID,
8594                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8595                 .adc_nids = alc882_adc_nids,
8596                 .capsrc_nids = alc882_capsrc_nids,
8597                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8598                 .channel_mode = alc882_3ST_6ch_modes,
8599                 .need_dac_fix = 1,
8600                 .input_mux = &alc882_capture_source,
8601                 .unsol_event = alc882_targa_unsol_event,
8602                 .init_hook = alc882_targa_init_hook,
8603         },
8604         [ALC882_ASUS_A7J] = {
8605                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
8606                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8607                                 alc882_asus_a7j_verbs},
8608                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8609                 .dac_nids = alc882_dac_nids,
8610                 .dig_out_nid = ALC882_DIGOUT_NID,
8611                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8612                 .adc_nids = alc882_adc_nids,
8613                 .capsrc_nids = alc882_capsrc_nids,
8614                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8615                 .channel_mode = alc882_3ST_6ch_modes,
8616                 .need_dac_fix = 1,
8617                 .input_mux = &alc882_capture_source,
8618         },
8619         [ALC882_ASUS_A7M] = {
8620                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
8621                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8622                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
8623                                 alc882_asus_a7m_verbs },
8624                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8625                 .dac_nids = alc882_dac_nids,
8626                 .dig_out_nid = ALC882_DIGOUT_NID,
8627                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8628                 .channel_mode = alc880_threestack_modes,
8629                 .need_dac_fix = 1,
8630                 .input_mux = &alc882_capture_source,
8631         },
8632         [ALC883_3ST_2ch_DIG] = {
8633                 .mixers = { alc883_3ST_2ch_mixer },
8634                 .init_verbs = { alc883_init_verbs },
8635                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8636                 .dac_nids = alc883_dac_nids,
8637                 .dig_out_nid = ALC883_DIGOUT_NID,
8638                 .dig_in_nid = ALC883_DIGIN_NID,
8639                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8640                 .channel_mode = alc883_3ST_2ch_modes,
8641                 .input_mux = &alc883_capture_source,
8642         },
8643         [ALC883_3ST_6ch_DIG] = {
8644                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8645                 .init_verbs = { alc883_init_verbs },
8646                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8647                 .dac_nids = alc883_dac_nids,
8648                 .dig_out_nid = ALC883_DIGOUT_NID,
8649                 .dig_in_nid = ALC883_DIGIN_NID,
8650                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8651                 .channel_mode = alc883_3ST_6ch_modes,
8652                 .need_dac_fix = 1,
8653                 .input_mux = &alc883_capture_source,
8654         },
8655         [ALC883_3ST_6ch] = {
8656                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8657                 .init_verbs = { alc883_init_verbs },
8658                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8659                 .dac_nids = alc883_dac_nids,
8660                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8661                 .channel_mode = alc883_3ST_6ch_modes,
8662                 .need_dac_fix = 1,
8663                 .input_mux = &alc883_capture_source,
8664         },
8665         [ALC883_3ST_6ch_INTEL] = {
8666                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8667                 .init_verbs = { alc883_init_verbs },
8668                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8669                 .dac_nids = alc883_dac_nids,
8670                 .dig_out_nid = ALC883_DIGOUT_NID,
8671                 .dig_in_nid = ALC883_DIGIN_NID,
8672                 .slave_dig_outs = alc883_slave_dig_outs,
8673                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8674                 .channel_mode = alc883_3ST_6ch_intel_modes,
8675                 .need_dac_fix = 1,
8676                 .input_mux = &alc883_3stack_6ch_intel,
8677         },
8678         [ALC883_6ST_DIG] = {
8679                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8680                 .init_verbs = { alc883_init_verbs },
8681                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8682                 .dac_nids = alc883_dac_nids,
8683                 .dig_out_nid = ALC883_DIGOUT_NID,
8684                 .dig_in_nid = ALC883_DIGIN_NID,
8685                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8686                 .channel_mode = alc883_sixstack_modes,
8687                 .input_mux = &alc883_capture_source,
8688         },
8689         [ALC883_TARGA_DIG] = {
8690                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
8691                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8692                                 alc883_targa_verbs},
8693                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8694                 .dac_nids = alc883_dac_nids,
8695                 .dig_out_nid = ALC883_DIGOUT_NID,
8696                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8697                 .channel_mode = alc883_3ST_6ch_modes,
8698                 .need_dac_fix = 1,
8699                 .input_mux = &alc883_capture_source,
8700                 .unsol_event = alc883_targa_unsol_event,
8701                 .init_hook = alc883_targa_init_hook,
8702         },
8703         [ALC883_TARGA_2ch_DIG] = {
8704                 .mixers = { alc883_targa_2ch_mixer},
8705                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8706                                 alc883_targa_verbs},
8707                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8708                 .dac_nids = alc883_dac_nids,
8709                 .adc_nids = alc883_adc_nids_alt,
8710                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8711                 .dig_out_nid = ALC883_DIGOUT_NID,
8712                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8713                 .channel_mode = alc883_3ST_2ch_modes,
8714                 .input_mux = &alc883_capture_source,
8715                 .unsol_event = alc883_targa_unsol_event,
8716                 .init_hook = alc883_targa_init_hook,
8717         },
8718         [ALC883_TARGA_8ch_DIG] = {
8719                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8720                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
8721                                 alc883_targa_verbs },
8722                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8723                 .dac_nids = alc883_dac_nids,
8724                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8725                 .adc_nids = alc883_adc_nids_rev,
8726                 .capsrc_nids = alc883_capsrc_nids_rev,
8727                 .dig_out_nid = ALC883_DIGOUT_NID,
8728                 .dig_in_nid = ALC883_DIGIN_NID,
8729                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
8730                 .channel_mode = alc883_4ST_8ch_modes,
8731                 .need_dac_fix = 1,
8732                 .input_mux = &alc883_capture_source,
8733                 .unsol_event = alc883_targa_unsol_event,
8734                 .init_hook = alc883_targa_init_hook,
8735         },
8736         [ALC883_ACER] = {
8737                 .mixers = { alc883_base_mixer },
8738                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
8739                  * and the headphone jack.  Turn this on and rely on the
8740                  * standard mute methods whenever the user wants to turn
8741                  * these outputs off.
8742                  */
8743                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
8744                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8745                 .dac_nids = alc883_dac_nids,
8746                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8747                 .channel_mode = alc883_3ST_2ch_modes,
8748                 .input_mux = &alc883_capture_source,
8749         },
8750         [ALC883_ACER_ASPIRE] = {
8751                 .mixers = { alc883_acer_aspire_mixer },
8752                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
8753                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8754                 .dac_nids = alc883_dac_nids,
8755                 .dig_out_nid = ALC883_DIGOUT_NID,
8756                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8757                 .channel_mode = alc883_3ST_2ch_modes,
8758                 .input_mux = &alc883_capture_source,
8759                 .unsol_event = alc_automute_amp_unsol_event,
8760                 .init_hook = alc883_acer_aspire_init_hook,
8761         },
8762         [ALC888_ACER_ASPIRE_4930G] = {
8763                 .mixers = { alc888_base_mixer,
8764                                 alc883_chmode_mixer },
8765                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8766                                 alc888_acer_aspire_4930g_verbs },
8767                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8768                 .dac_nids = alc883_dac_nids,
8769                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8770                 .adc_nids = alc883_adc_nids_rev,
8771                 .capsrc_nids = alc883_capsrc_nids_rev,
8772                 .dig_out_nid = ALC883_DIGOUT_NID,
8773                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8774                 .channel_mode = alc883_3ST_6ch_modes,
8775                 .need_dac_fix = 1,
8776                 .num_mux_defs =
8777                         ARRAY_SIZE(alc888_2_capture_sources),
8778                 .input_mux = alc888_2_capture_sources,
8779                 .unsol_event = alc_automute_amp_unsol_event,
8780                 .init_hook = alc888_acer_aspire_4930g_init_hook,
8781         },
8782         [ALC888_ACER_ASPIRE_6530G] = {
8783                 .mixers = { alc888_acer_aspire_6530_mixer },
8784                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8785                                 alc888_acer_aspire_6530g_verbs },
8786                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8787                 .dac_nids = alc883_dac_nids,
8788                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8789                 .adc_nids = alc883_adc_nids_rev,
8790                 .capsrc_nids = alc883_capsrc_nids_rev,
8791                 .dig_out_nid = ALC883_DIGOUT_NID,
8792                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8793                 .channel_mode = alc883_3ST_2ch_modes,
8794                 .num_mux_defs =
8795                         ARRAY_SIZE(alc888_2_capture_sources),
8796                 .input_mux = alc888_acer_aspire_6530_sources,
8797                 .unsol_event = alc_automute_amp_unsol_event,
8798                 .init_hook = alc888_acer_aspire_6530g_init_hook,
8799         },
8800         [ALC888_ACER_ASPIRE_8930G] = {
8801                 .mixers = { alc888_base_mixer,
8802                                 alc883_chmode_mixer },
8803                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
8804                                 alc889_acer_aspire_8930g_verbs },
8805                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8806                 .dac_nids = alc883_dac_nids,
8807                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
8808                 .adc_nids = alc889_adc_nids,
8809                 .capsrc_nids = alc889_capsrc_nids,
8810                 .dig_out_nid = ALC883_DIGOUT_NID,
8811                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8812                 .channel_mode = alc883_3ST_6ch_modes,
8813                 .need_dac_fix = 1,
8814                 .const_channel_count = 6,
8815                 .num_mux_defs =
8816                         ARRAY_SIZE(alc889_capture_sources),
8817                 .input_mux = alc889_capture_sources,
8818                 .unsol_event = alc_automute_amp_unsol_event,
8819                 .init_hook = alc889_acer_aspire_8930g_init_hook,
8820         },
8821         [ALC883_MEDION] = {
8822                 .mixers = { alc883_fivestack_mixer,
8823                             alc883_chmode_mixer },
8824                 .init_verbs = { alc883_init_verbs,
8825                                 alc883_medion_eapd_verbs },
8826                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8827                 .dac_nids = alc883_dac_nids,
8828                 .adc_nids = alc883_adc_nids_alt,
8829                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8830                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8831                 .channel_mode = alc883_sixstack_modes,
8832                 .input_mux = &alc883_capture_source,
8833         },
8834         [ALC883_MEDION_MD2] = {
8835                 .mixers = { alc883_medion_md2_mixer},
8836                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
8837                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8838                 .dac_nids = alc883_dac_nids,
8839                 .dig_out_nid = ALC883_DIGOUT_NID,
8840                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8841                 .channel_mode = alc883_3ST_2ch_modes,
8842                 .input_mux = &alc883_capture_source,
8843                 .unsol_event = alc_automute_amp_unsol_event,
8844                 .init_hook = alc883_medion_md2_init_hook,
8845         },
8846         [ALC883_LAPTOP_EAPD] = {
8847                 .mixers = { alc883_base_mixer },
8848                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
8849                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8850                 .dac_nids = alc883_dac_nids,
8851                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8852                 .channel_mode = alc883_3ST_2ch_modes,
8853                 .input_mux = &alc883_capture_source,
8854         },
8855         [ALC883_CLEVO_M720] = {
8856                 .mixers = { alc883_clevo_m720_mixer },
8857                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
8858                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8859                 .dac_nids = alc883_dac_nids,
8860                 .dig_out_nid = ALC883_DIGOUT_NID,
8861                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8862                 .channel_mode = alc883_3ST_2ch_modes,
8863                 .input_mux = &alc883_capture_source,
8864                 .unsol_event = alc883_clevo_m720_unsol_event,
8865                 .init_hook = alc883_clevo_m720_init_hook,
8866         },
8867         [ALC883_LENOVO_101E_2ch] = {
8868                 .mixers = { alc883_lenovo_101e_2ch_mixer},
8869                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
8870                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8871                 .dac_nids = alc883_dac_nids,
8872                 .adc_nids = alc883_adc_nids_alt,
8873                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
8874                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8875                 .channel_mode = alc883_3ST_2ch_modes,
8876                 .input_mux = &alc883_lenovo_101e_capture_source,
8877                 .unsol_event = alc883_lenovo_101e_unsol_event,
8878                 .init_hook = alc883_lenovo_101e_all_automute,
8879         },
8880         [ALC883_LENOVO_NB0763] = {
8881                 .mixers = { alc883_lenovo_nb0763_mixer },
8882                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
8883                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8884                 .dac_nids = alc883_dac_nids,
8885                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8886                 .channel_mode = alc883_3ST_2ch_modes,
8887                 .need_dac_fix = 1,
8888                 .input_mux = &alc883_lenovo_nb0763_capture_source,
8889                 .unsol_event = alc_automute_amp_unsol_event,
8890                 .init_hook = alc883_medion_md2_init_hook,
8891         },
8892         [ALC888_LENOVO_MS7195_DIG] = {
8893                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8894                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
8895                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8896                 .dac_nids = alc883_dac_nids,
8897                 .dig_out_nid = ALC883_DIGOUT_NID,
8898                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8899                 .channel_mode = alc883_3ST_6ch_modes,
8900                 .need_dac_fix = 1,
8901                 .input_mux = &alc883_capture_source,
8902                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
8903                 .init_hook = alc888_lenovo_ms7195_front_automute,
8904         },
8905         [ALC883_HAIER_W66] = {
8906                 .mixers = { alc883_targa_2ch_mixer},
8907                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
8908                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8909                 .dac_nids = alc883_dac_nids,
8910                 .dig_out_nid = ALC883_DIGOUT_NID,
8911                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8912                 .channel_mode = alc883_3ST_2ch_modes,
8913                 .input_mux = &alc883_capture_source,
8914                 .unsol_event = alc_automute_amp_unsol_event,
8915                 .init_hook = alc883_haier_w66_init_hook,
8916         },
8917         [ALC888_3ST_HP] = {
8918                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8919                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
8920                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8921                 .dac_nids = alc883_dac_nids,
8922                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
8923                 .channel_mode = alc888_3st_hp_modes,
8924                 .need_dac_fix = 1,
8925                 .input_mux = &alc883_capture_source,
8926                 .unsol_event = alc_automute_amp_unsol_event,
8927                 .init_hook = alc888_3st_hp_init_hook,
8928         },
8929         [ALC888_6ST_DELL] = {
8930                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
8931                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
8932                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8933                 .dac_nids = alc883_dac_nids,
8934                 .dig_out_nid = ALC883_DIGOUT_NID,
8935                 .dig_in_nid = ALC883_DIGIN_NID,
8936                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8937                 .channel_mode = alc883_sixstack_modes,
8938                 .input_mux = &alc883_capture_source,
8939                 .unsol_event = alc_automute_amp_unsol_event,
8940                 .init_hook = alc888_6st_dell_init_hook,
8941         },
8942         [ALC883_MITAC] = {
8943                 .mixers = { alc883_mitac_mixer },
8944                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
8945                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8946                 .dac_nids = alc883_dac_nids,
8947                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8948                 .channel_mode = alc883_3ST_2ch_modes,
8949                 .input_mux = &alc883_capture_source,
8950                 .unsol_event = alc_automute_amp_unsol_event,
8951                 .init_hook = alc883_mitac_init_hook,
8952         },
8953         [ALC883_FUJITSU_PI2515] = {
8954                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
8955                 .init_verbs = { alc883_init_verbs,
8956                                 alc883_2ch_fujitsu_pi2515_verbs},
8957                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8958                 .dac_nids = alc883_dac_nids,
8959                 .dig_out_nid = ALC883_DIGOUT_NID,
8960                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8961                 .channel_mode = alc883_3ST_2ch_modes,
8962                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
8963                 .unsol_event = alc_automute_amp_unsol_event,
8964                 .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
8965         },
8966         [ALC888_FUJITSU_XA3530] = {
8967                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
8968                 .init_verbs = { alc883_init_verbs,
8969                         alc888_fujitsu_xa3530_verbs },
8970                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8971                 .dac_nids = alc883_dac_nids,
8972                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
8973                 .adc_nids = alc883_adc_nids_rev,
8974                 .capsrc_nids = alc883_capsrc_nids_rev,
8975                 .dig_out_nid = ALC883_DIGOUT_NID,
8976                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
8977                 .channel_mode = alc888_4ST_8ch_intel_modes,
8978                 .num_mux_defs =
8979                         ARRAY_SIZE(alc888_2_capture_sources),
8980                 .input_mux = alc888_2_capture_sources,
8981                 .unsol_event = alc_automute_amp_unsol_event,
8982                 .init_hook = alc888_fujitsu_xa3530_init_hook,
8983         },
8984         [ALC888_LENOVO_SKY] = {
8985                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
8986                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
8987                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8988                 .dac_nids = alc883_dac_nids,
8989                 .dig_out_nid = ALC883_DIGOUT_NID,
8990                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
8991                 .channel_mode = alc883_sixstack_modes,
8992                 .need_dac_fix = 1,
8993                 .input_mux = &alc883_lenovo_sky_capture_source,
8994                 .unsol_event = alc_automute_amp_unsol_event,
8995                 .init_hook = alc888_lenovo_sky_init_hook,
8996         },
8997         [ALC888_ASUS_M90V] = {
8998                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8999                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9000                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9001                 .dac_nids = alc883_dac_nids,
9002                 .dig_out_nid = ALC883_DIGOUT_NID,
9003                 .dig_in_nid = ALC883_DIGIN_NID,
9004                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9005                 .channel_mode = alc883_3ST_6ch_modes,
9006                 .need_dac_fix = 1,
9007                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9008                 .unsol_event = alc883_mode2_unsol_event,
9009                 .init_hook = alc883_mode2_inithook,
9010         },
9011         [ALC888_ASUS_EEE1601] = {
9012                 .mixers = { alc883_asus_eee1601_mixer },
9013                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9014                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9015                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9016                 .dac_nids = alc883_dac_nids,
9017                 .dig_out_nid = ALC883_DIGOUT_NID,
9018                 .dig_in_nid = ALC883_DIGIN_NID,
9019                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9020                 .channel_mode = alc883_3ST_2ch_modes,
9021                 .need_dac_fix = 1,
9022                 .input_mux = &alc883_asus_eee1601_capture_source,
9023                 .unsol_event = alc_sku_unsol_event,
9024                 .init_hook = alc883_eee1601_inithook,
9025         },
9026         [ALC1200_ASUS_P5Q] = {
9027                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9028                 .init_verbs = { alc883_init_verbs },
9029                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9030                 .dac_nids = alc883_dac_nids,
9031                 .dig_out_nid = ALC1200_DIGOUT_NID,
9032                 .dig_in_nid = ALC883_DIGIN_NID,
9033                 .slave_dig_outs = alc1200_slave_dig_outs,
9034                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9035                 .channel_mode = alc883_sixstack_modes,
9036                 .input_mux = &alc883_capture_source,
9037         },
9038         [ALC889A_MB31] = {
9039                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9040                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9041                         alc880_gpio1_init_verbs },
9042                 .adc_nids = alc883_adc_nids,
9043                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9044                 .dac_nids = alc883_dac_nids,
9045                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9046                 .channel_mode = alc889A_mb31_6ch_modes,
9047                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9048                 .input_mux = &alc889A_mb31_capture_source,
9049                 .dig_out_nid = ALC883_DIGOUT_NID,
9050                 .unsol_event = alc889A_mb31_unsol_event,
9051                 .init_hook = alc889A_mb31_automute,
9052         },
9053         [ALC883_SONY_VAIO_TT] = {
9054                 .mixers = { alc883_vaiott_mixer },
9055                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9056                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9057                 .dac_nids = alc883_dac_nids,
9058                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9059                 .channel_mode = alc883_3ST_2ch_modes,
9060                 .input_mux = &alc883_capture_source,
9061                 .unsol_event = alc_automute_amp_unsol_event,
9062                 .init_hook = alc883_vaiott_init_hook,
9063         },
9064 };
9065
9066
9067 /*
9068  * Pin config fixes
9069  */
9070 enum {
9071         PINFIX_ABIT_AW9D_MAX
9072 };
9073
9074 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9075         { 0x15, 0x01080104 }, /* side */
9076         { 0x16, 0x01011012 }, /* rear */
9077         { 0x17, 0x01016011 }, /* clfe */
9078         { }
9079 };
9080
9081 static const struct alc_pincfg *alc882_pin_fixes[] = {
9082         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
9083 };
9084
9085 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
9086         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9087         {}
9088 };
9089
9090 /*
9091  * BIOS auto configuration
9092  */
9093 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9094                                               hda_nid_t nid, int pin_type,
9095                                               int dac_idx)
9096 {
9097         /* set as output */
9098         struct alc_spec *spec = codec->spec;
9099         int idx;
9100
9101         alc_set_pin_output(codec, nid, pin_type);
9102         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9103                 idx = 4;
9104         else
9105                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9106         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9107
9108 }
9109
9110 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9111 {
9112         struct alc_spec *spec = codec->spec;
9113         int i;
9114
9115         for (i = 0; i <= HDA_SIDE; i++) {
9116                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9117                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9118                 if (nid)
9119                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9120                                                           i);
9121         }
9122 }
9123
9124 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9125 {
9126         struct alc_spec *spec = codec->spec;
9127         hda_nid_t pin;
9128
9129         pin = spec->autocfg.hp_pins[0];
9130         if (pin) /* connect to front */
9131                 /* use dac 0 */
9132                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9133         pin = spec->autocfg.speaker_pins[0];
9134         if (pin)
9135                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9136 }
9137
9138 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9139 {
9140         struct alc_spec *spec = codec->spec;
9141         int i;
9142
9143         for (i = 0; i < AUTO_PIN_LAST; i++) {
9144                 hda_nid_t nid = spec->autocfg.input_pins[i];
9145                 if (!nid)
9146                         continue;
9147                 alc_set_input_pin(codec, nid, i);
9148                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9149                         snd_hda_codec_write(codec, nid, 0,
9150                                             AC_VERB_SET_AMP_GAIN_MUTE,
9151                                             AMP_OUT_MUTE);
9152         }
9153 }
9154
9155 static void alc882_auto_init_input_src(struct hda_codec *codec)
9156 {
9157         struct alc_spec *spec = codec->spec;
9158         int c;
9159
9160         for (c = 0; c < spec->num_adc_nids; c++) {
9161                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9162                 hda_nid_t nid = spec->capsrc_nids[c];
9163                 unsigned int mux_idx;
9164                 const struct hda_input_mux *imux;
9165                 int conns, mute, idx, item;
9166
9167                 conns = snd_hda_get_connections(codec, nid, conn_list,
9168                                                 ARRAY_SIZE(conn_list));
9169                 if (conns < 0)
9170                         continue;
9171                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9172                 imux = &spec->input_mux[mux_idx];
9173                 for (idx = 0; idx < conns; idx++) {
9174                         /* if the current connection is the selected one,
9175                          * unmute it as default - otherwise mute it
9176                          */
9177                         mute = AMP_IN_MUTE(idx);
9178                         for (item = 0; item < imux->num_items; item++) {
9179                                 if (imux->items[item].index == idx) {
9180                                         if (spec->cur_mux[c] == item)
9181                                                 mute = AMP_IN_UNMUTE(idx);
9182                                         break;
9183                                 }
9184                         }
9185                         /* check if we have a selector or mixer
9186                          * we could check for the widget type instead, but
9187                          * just check for Amp-In presence (in case of mixer
9188                          * without amp-in there is something wrong, this
9189                          * function shouldn't be used or capsrc nid is wrong)
9190                          */
9191                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9192                                 snd_hda_codec_write(codec, nid, 0,
9193                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9194                                                     mute);
9195                         else if (mute != AMP_IN_MUTE(idx))
9196                                 snd_hda_codec_write(codec, nid, 0,
9197                                                     AC_VERB_SET_CONNECT_SEL,
9198                                                     idx);
9199                 }
9200         }
9201 }
9202
9203 /* add mic boosts if needed */
9204 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9205 {
9206         struct alc_spec *spec = codec->spec;
9207         int err;
9208         hda_nid_t nid;
9209
9210         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9211         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9212                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9213                                   "Mic Boost",
9214                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9215                 if (err < 0)
9216                         return err;
9217         }
9218         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9219         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9220                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9221                                   "Front Mic Boost",
9222                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9223                 if (err < 0)
9224                         return err;
9225         }
9226         return 0;
9227 }
9228
9229 /* almost identical with ALC880 parser... */
9230 static int alc882_parse_auto_config(struct hda_codec *codec)
9231 {
9232         struct alc_spec *spec = codec->spec;
9233         struct auto_pin_cfg *autocfg = &spec->autocfg;
9234         unsigned int wcap;
9235         int i;
9236         int err = alc880_parse_auto_config(codec);
9237
9238         if (err < 0)
9239                 return err;
9240         else if (!err)
9241                 return 0; /* no config found */
9242
9243         err = alc_auto_add_mic_boost(codec);
9244         if (err < 0)
9245                 return err;
9246
9247         /* hack - override the init verbs */
9248         spec->init_verbs[0] = alc883_auto_init_verbs;
9249         /* if ADC 0x07 is available, initialize it, too */
9250         wcap = get_wcaps(codec, 0x07);
9251         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9252         if (wcap == AC_WID_AUD_IN)
9253                 add_verb(spec, alc882_adc1_init_verbs);
9254
9255         /* digital-mic input pin is excluded in alc880_auto_create..()
9256          * because it's under 0x18
9257          */
9258         if (autocfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9259             autocfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9260                 struct hda_input_mux *imux = &spec->private_imux[0];
9261                 for (i = 1; i < 3; i++)
9262                         memcpy(&spec->private_imux[i],
9263                                &spec->private_imux[0],
9264                                sizeof(spec->private_imux[0]));
9265                 imux->items[imux->num_items].label = "Int DMic";
9266                 imux->items[imux->num_items].index = 0x0b;
9267                 imux->num_items++;
9268                 spec->num_mux_defs = 3;
9269                 spec->input_mux = spec->private_imux;
9270         }
9271
9272         return 1; /* config found */
9273 }
9274
9275 /* additional initialization for auto-configuration model */
9276 static void alc882_auto_init(struct hda_codec *codec)
9277 {
9278         struct alc_spec *spec = codec->spec;
9279         alc882_auto_init_multi_out(codec);
9280         alc882_auto_init_hp_out(codec);
9281         alc882_auto_init_analog_input(codec);
9282         alc882_auto_init_input_src(codec);
9283         if (spec->unsol_event)
9284                 alc_inithook(codec);
9285 }
9286
9287 static int patch_alc882(struct hda_codec *codec)
9288 {
9289         struct alc_spec *spec;
9290         int err, board_config;
9291
9292         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9293         if (spec == NULL)
9294                 return -ENOMEM;
9295
9296         codec->spec = spec;
9297
9298         switch (codec->vendor_id) {
9299         case 0x10ec0882:
9300         case 0x10ec0885:
9301                 break;
9302         default:
9303                 /* ALC883 and variants */
9304                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9305                 break;
9306         }
9307
9308         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
9309                                                   alc882_models,
9310                                                   alc882_cfg_tbl);
9311
9312         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
9313                 board_config = snd_hda_check_board_codec_sid_config(codec,
9314                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
9315
9316         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
9317                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
9318                        "trying auto-probe from BIOS...\n",
9319                        codec->chip_name);
9320                 board_config = ALC882_AUTO;
9321         }
9322
9323         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
9324
9325         if (board_config == ALC882_AUTO) {
9326                 /* automatic parse from the BIOS config */
9327                 err = alc882_parse_auto_config(codec);
9328                 if (err < 0) {
9329                         alc_free(codec);
9330                         return err;
9331                 } else if (!err) {
9332                         printk(KERN_INFO
9333                                "hda_codec: Cannot set up configuration "
9334                                "from BIOS.  Using base mode...\n");
9335                         board_config = ALC882_3ST_DIG;
9336                 }
9337         }
9338
9339         err = snd_hda_attach_beep_device(codec, 0x1);
9340         if (err < 0) {
9341                 alc_free(codec);
9342                 return err;
9343         }
9344
9345         if (board_config != ALC882_AUTO)
9346                 setup_preset(spec, &alc882_presets[board_config]);
9347
9348         spec->stream_analog_playback = &alc882_pcm_analog_playback;
9349         spec->stream_analog_capture = &alc882_pcm_analog_capture;
9350         /* FIXME: setup DAC5 */
9351         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
9352         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
9353
9354         spec->stream_digital_playback = &alc882_pcm_digital_playback;
9355         spec->stream_digital_capture = &alc882_pcm_digital_capture;
9356
9357         if (codec->vendor_id == 0x10ec0888)
9358                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9359
9360         if (!spec->adc_nids && spec->input_mux) {
9361                 int i;
9362                 spec->num_adc_nids = 0;
9363                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
9364                         hda_nid_t cap;
9365                         hda_nid_t nid = alc882_adc_nids[i];
9366                         unsigned int wcap = get_wcaps(codec, nid);
9367                         /* get type */
9368                         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
9369                         if (wcap != AC_WID_AUD_IN)
9370                                 continue;
9371                         spec->private_adc_nids[spec->num_adc_nids] = nid;
9372                         err = snd_hda_get_connections(codec, nid, &cap, 1);
9373                         if (err < 0)
9374                                 continue;
9375                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
9376                         spec->num_adc_nids++;
9377                 }
9378                 spec->adc_nids = spec->private_adc_nids;
9379                 spec->capsrc_nids = spec->private_capsrc_nids;
9380         }
9381
9382         set_capture_mixer(spec);
9383         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9384
9385         spec->vmaster_nid = 0x0c;
9386
9387         codec->patch_ops = alc_patch_ops;
9388         if (board_config == ALC882_AUTO)
9389                 spec->init_hook = alc882_auto_init;
9390 #ifdef CONFIG_SND_HDA_POWER_SAVE
9391         if (!spec->loopback.amplist)
9392                 spec->loopback.amplist = alc882_loopbacks;
9393 #endif
9394         codec->proc_widget_hook = print_realtek_coef;
9395
9396         return 0;
9397 }
9398
9399
9400 /*
9401  * ALC262 support
9402  */
9403
9404 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9405 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9406
9407 #define alc262_dac_nids         alc260_dac_nids
9408 #define alc262_adc_nids         alc882_adc_nids
9409 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9410 #define alc262_capsrc_nids      alc882_capsrc_nids
9411 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9412
9413 #define alc262_modes            alc260_modes
9414 #define alc262_capture_source   alc882_capture_source
9415
9416 static hda_nid_t alc262_dmic_adc_nids[1] = {
9417         /* ADC0 */
9418         0x09
9419 };
9420
9421 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9422
9423 static struct snd_kcontrol_new alc262_base_mixer[] = {
9424         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9425         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9426         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9427         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9428         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9429         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9430         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9431         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9432         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9433         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9434         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9435         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9436         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9437         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9438         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9439         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9440         { } /* end */
9441 };
9442
9443 /* update HP, line and mono-out pins according to the master switch */
9444 static void alc262_hp_master_update(struct hda_codec *codec)
9445 {
9446         struct alc_spec *spec = codec->spec;
9447         int val = spec->master_sw;
9448
9449         /* HP & line-out */
9450         snd_hda_codec_write_cache(codec, 0x1b, 0,
9451                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9452                                   val ? PIN_HP : 0);
9453         snd_hda_codec_write_cache(codec, 0x15, 0,
9454                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9455                                   val ? PIN_HP : 0);
9456         /* mono (speaker) depending on the HP jack sense */
9457         val = val && !spec->jack_present;
9458         snd_hda_codec_write_cache(codec, 0x16, 0,
9459                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9460                                   val ? PIN_OUT : 0);
9461 }
9462
9463 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9464 {
9465         struct alc_spec *spec = codec->spec;
9466         unsigned int presence;
9467         presence = snd_hda_codec_read(codec, 0x1b, 0,
9468                                       AC_VERB_GET_PIN_SENSE, 0);
9469         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9470         alc262_hp_master_update(codec);
9471 }
9472
9473 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9474 {
9475         if ((res >> 26) != ALC880_HP_EVENT)
9476                 return;
9477         alc262_hp_bpc_automute(codec);
9478 }
9479
9480 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9481 {
9482         struct alc_spec *spec = codec->spec;
9483         unsigned int presence;
9484         presence = snd_hda_codec_read(codec, 0x15, 0,
9485                                       AC_VERB_GET_PIN_SENSE, 0);
9486         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9487         alc262_hp_master_update(codec);
9488 }
9489
9490 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9491                                            unsigned int res)
9492 {
9493         if ((res >> 26) != ALC880_HP_EVENT)
9494                 return;
9495         alc262_hp_wildwest_automute(codec);
9496 }
9497
9498 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
9499
9500 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9501                                    struct snd_ctl_elem_value *ucontrol)
9502 {
9503         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9504         struct alc_spec *spec = codec->spec;
9505         int val = !!*ucontrol->value.integer.value;
9506
9507         if (val == spec->master_sw)
9508                 return 0;
9509         spec->master_sw = val;
9510         alc262_hp_master_update(codec);
9511         return 1;
9512 }
9513
9514 #define ALC262_HP_MASTER_SWITCH                                 \
9515         {                                                       \
9516                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9517                 .name = "Master Playback Switch",               \
9518                 .info = snd_ctl_boolean_mono_info,              \
9519                 .get = alc262_hp_master_sw_get,                 \
9520                 .put = alc262_hp_master_sw_put,                 \
9521         }
9522
9523 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9524         ALC262_HP_MASTER_SWITCH,
9525         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9526         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9527         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9528         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9529                               HDA_OUTPUT),
9530         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9531                             HDA_OUTPUT),
9532         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9533         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9534         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9535         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9536         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9537         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9538         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9539         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9540         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9541         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9542         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9543         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9544         { } /* end */
9545 };
9546
9547 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9548         ALC262_HP_MASTER_SWITCH,
9549         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9550         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9551         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9552         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9553         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9554                               HDA_OUTPUT),
9555         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9556                             HDA_OUTPUT),
9557         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9558         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9559         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9560         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9561         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9562         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9563         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9564         { } /* end */
9565 };
9566
9567 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9568         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9569         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9570         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9571         { } /* end */
9572 };
9573
9574 /* mute/unmute internal speaker according to the hp jack and mute state */
9575 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9576 {
9577         struct alc_spec *spec = codec->spec;
9578
9579         spec->autocfg.hp_pins[0] = 0x15;
9580         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
9581         alc_automute_amp(codec);
9582 }
9583
9584 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9585         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9586         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9587         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9588         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9589         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9590         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9591         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9592         { } /* end */
9593 };
9594
9595 static struct hda_verb alc262_hp_t5735_verbs[] = {
9596         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9597         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9598
9599         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9600         { }
9601 };
9602
9603 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9604         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9605         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9606         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9607         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9608         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9609         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9610         { } /* end */
9611 };
9612
9613 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9614         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9615         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9616         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9617         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9618         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9619         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9620         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9621         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9623         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9624         {}
9625 };
9626
9627 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9628         .num_items = 1,
9629         .items = {
9630                 { "Line", 0x1 },
9631         },
9632 };
9633
9634 /* bind hp and internal speaker mute (with plug check) as master switch */
9635 static void alc262_hippo_master_update(struct hda_codec *codec)
9636 {
9637         struct alc_spec *spec = codec->spec;
9638         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9639         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9640         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9641         unsigned int mute;
9642
9643         /* HP */
9644         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
9645         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
9646                                  HDA_AMP_MUTE, mute);
9647         /* mute internal speaker per jack sense */
9648         if (spec->jack_present)
9649                 mute = HDA_AMP_MUTE;
9650         if (line_nid)
9651                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
9652                                          HDA_AMP_MUTE, mute);
9653         if (speaker_nid && speaker_nid != line_nid)
9654                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
9655                                          HDA_AMP_MUTE, mute);
9656 }
9657
9658 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
9659
9660 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
9661                                       struct snd_ctl_elem_value *ucontrol)
9662 {
9663         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9664         struct alc_spec *spec = codec->spec;
9665         int val = !!*ucontrol->value.integer.value;
9666
9667         if (val == spec->master_sw)
9668                 return 0;
9669         spec->master_sw = val;
9670         alc262_hippo_master_update(codec);
9671         return 1;
9672 }
9673
9674 #define ALC262_HIPPO_MASTER_SWITCH                              \
9675         {                                                       \
9676                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9677                 .name = "Master Playback Switch",               \
9678                 .info = snd_ctl_boolean_mono_info,              \
9679                 .get = alc262_hippo_master_sw_get,              \
9680                 .put = alc262_hippo_master_sw_put,              \
9681         }
9682
9683 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
9684         ALC262_HIPPO_MASTER_SWITCH,
9685         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9686         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9687         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9688         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9689         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9690         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9691         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9692         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9693         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9694         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9695         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9696         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9697         { } /* end */
9698 };
9699
9700 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
9701         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9702         ALC262_HIPPO_MASTER_SWITCH,
9703         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9704         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9705         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9706         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9707         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9708         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9709         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9710         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9711         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9712         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9713         { } /* end */
9714 };
9715
9716 /* mute/unmute internal speaker according to the hp jack and mute state */
9717 static void alc262_hippo_automute(struct hda_codec *codec)
9718 {
9719         struct alc_spec *spec = codec->spec;
9720         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9721         unsigned int present;
9722
9723         /* need to execute and sync at first */
9724         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
9725         present = snd_hda_codec_read(codec, hp_nid, 0,
9726                                      AC_VERB_GET_PIN_SENSE, 0);
9727         spec->jack_present = (present & 0x80000000) != 0;
9728         alc262_hippo_master_update(codec);
9729 }
9730
9731 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
9732 {
9733         if ((res >> 26) != ALC880_HP_EVENT)
9734                 return;
9735         alc262_hippo_automute(codec);
9736 }
9737
9738 static void alc262_hippo_init_hook(struct hda_codec *codec)
9739 {
9740         struct alc_spec *spec = codec->spec;
9741
9742         spec->autocfg.hp_pins[0] = 0x15;
9743         spec->autocfg.speaker_pins[0] = 0x14;
9744         alc262_hippo_automute(codec);
9745 }
9746
9747 static void alc262_hippo1_init_hook(struct hda_codec *codec)
9748 {
9749         struct alc_spec *spec = codec->spec;
9750
9751         spec->autocfg.hp_pins[0] = 0x1b;
9752         spec->autocfg.speaker_pins[0] = 0x14;
9753         alc262_hippo_automute(codec);
9754 }
9755
9756
9757 static struct snd_kcontrol_new alc262_sony_mixer[] = {
9758         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9759         ALC262_HIPPO_MASTER_SWITCH,
9760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9761         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9762         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9763         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9764         { } /* end */
9765 };
9766
9767 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
9768         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9769         ALC262_HIPPO_MASTER_SWITCH,
9770         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9771         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9772         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9773         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9774         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9775         { } /* end */
9776 };
9777
9778 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
9779         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9780         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
9781         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
9782         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
9783         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9784         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9787         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9788         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9789         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9790         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9791         { } /* end */
9792 };
9793
9794 static struct hda_verb alc262_tyan_verbs[] = {
9795         /* Headphone automute */
9796         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9797         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9798         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9799
9800         /* P11 AUX_IN, white 4-pin connector */
9801         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9802         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
9803         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
9804         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
9805
9806         {}
9807 };
9808
9809 /* unsolicited event for HP jack sensing */
9810 static void alc262_tyan_init_hook(struct hda_codec *codec)
9811 {
9812         struct alc_spec *spec = codec->spec;
9813
9814         spec->autocfg.hp_pins[0] = 0x1b;
9815         spec->autocfg.speaker_pins[0] = 0x15;
9816         alc_automute_amp(codec);
9817 }
9818
9819
9820 #define alc262_capture_mixer            alc882_capture_mixer
9821 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
9822
9823 /*
9824  * generic initialization of ADC, input mixers and output mixers
9825  */
9826 static struct hda_verb alc262_init_verbs[] = {
9827         /*
9828          * Unmute ADC0-2 and set the default input to mic-in
9829          */
9830         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
9831         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9832         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
9833         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9834         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
9835         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9836
9837         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
9838          * mixer widget
9839          * Note: PASD motherboards uses the Line In 2 as the input for
9840          * front panel mic (mic 2)
9841          */
9842         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
9843         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9844         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9845         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
9846         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
9847         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
9848
9849         /*
9850          * Set up output mixers (0x0c - 0x0e)
9851          */
9852         /* set vol=0 to output mixers */
9853         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9854         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9855         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
9856         /* set up input amps for analog loopback */
9857         /* Amp Indices: DAC = 0, mixer = 1 */
9858         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9860         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9861         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9862         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9863         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9864
9865         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9866         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9867         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
9868         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9869         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9870         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
9871
9872         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9873         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9874         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9875         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9876         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9877
9878         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9879         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9880
9881         /* FIXME: use matrix-type input source selection */
9882         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
9883         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
9884         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9885         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9886         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9887         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9888         /* Input mixer2 */
9889         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9890         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9891         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9892         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9893         /* Input mixer3 */
9894         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
9895         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
9896         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
9897         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
9898
9899         { }
9900 };
9901
9902 static struct hda_verb alc262_eapd_verbs[] = {
9903         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
9904         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
9905         { }
9906 };
9907
9908 static struct hda_verb alc262_hippo_unsol_verbs[] = {
9909         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9910         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9911         {}
9912 };
9913
9914 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
9915         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9916         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9917         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
9918
9919         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9921         {}
9922 };
9923
9924 static struct hda_verb alc262_sony_unsol_verbs[] = {
9925         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
9926         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9927         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
9928
9929         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9930         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9931         {}
9932 };
9933
9934 static struct hda_input_mux alc262_dmic_capture_source = {
9935         .num_items = 2,
9936         .items = {
9937                 { "Int DMic", 0x9 },
9938                 { "Mic", 0x0 },
9939         },
9940 };
9941
9942 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
9943         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9944         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9945         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9946         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9948         { } /* end */
9949 };
9950
9951 static struct hda_verb alc262_toshiba_s06_verbs[] = {
9952         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9953         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9954         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9955         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9956         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
9957         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
9958         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
9959         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
9960         {}
9961 };
9962
9963 static void alc262_dmic_automute(struct hda_codec *codec)
9964 {
9965         unsigned int present;
9966
9967         present = snd_hda_codec_read(codec, 0x18, 0,
9968                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
9969         snd_hda_codec_write(codec, 0x22, 0,
9970                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
9971 }
9972
9973
9974 /* unsolicited event for HP jack sensing */
9975 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
9976                                        unsigned int res)
9977 {
9978         if ((res >> 26) == ALC880_MIC_EVENT)
9979                 alc262_dmic_automute(codec);
9980         else
9981                 alc_sku_unsol_event(codec, res);
9982 }
9983
9984 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
9985 {
9986         struct alc_spec *spec = codec->spec;
9987
9988         spec->autocfg.hp_pins[0] = 0x15;
9989         spec->autocfg.speaker_pins[0] = 0x14;
9990         alc_automute_pin(codec);
9991         alc262_dmic_automute(codec);
9992 }
9993
9994 /*
9995  * nec model
9996  *  0x15 = headphone
9997  *  0x16 = internal speaker
9998  *  0x18 = external mic
9999  */
10000
10001 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10002         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10003         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10004
10005         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10006         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10007         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10008
10009         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10010         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10011         { } /* end */
10012 };
10013
10014 static struct hda_verb alc262_nec_verbs[] = {
10015         /* Unmute Speaker */
10016         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10017
10018         /* Headphone */
10019         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10020         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10021
10022         /* External mic to headphone */
10023         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10024         /* External mic to speaker */
10025         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10026         {}
10027 };
10028
10029 /*
10030  * fujitsu model
10031  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10032  *  0x1b = port replicator headphone out
10033  */
10034
10035 #define ALC_HP_EVENT    0x37
10036
10037 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10038         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10039         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10040         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10041         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10042         {}
10043 };
10044
10045 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10046         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10047         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10048         {}
10049 };
10050
10051 static struct hda_input_mux alc262_fujitsu_capture_source = {
10052         .num_items = 3,
10053         .items = {
10054                 { "Mic", 0x0 },
10055                 { "Int Mic", 0x1 },
10056                 { "CD", 0x4 },
10057         },
10058 };
10059
10060 static struct hda_input_mux alc262_HP_capture_source = {
10061         .num_items = 5,
10062         .items = {
10063                 { "Mic", 0x0 },
10064                 { "Front Mic", 0x1 },
10065                 { "Line", 0x2 },
10066                 { "CD", 0x4 },
10067                 { "AUX IN", 0x6 },
10068         },
10069 };
10070
10071 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10072         .num_items = 4,
10073         .items = {
10074                 { "Mic", 0x0 },
10075                 { "Front Mic", 0x2 },
10076                 { "Line", 0x1 },
10077                 { "CD", 0x4 },
10078         },
10079 };
10080
10081 /* mute/unmute internal speaker according to the hp jacks and mute state */
10082 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10083 {
10084         struct alc_spec *spec = codec->spec;
10085         unsigned int mute;
10086
10087         if (force || !spec->sense_updated) {
10088                 unsigned int present;
10089                 /* need to execute and sync at first */
10090                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10091                 /* check laptop HP jack */
10092                 present = snd_hda_codec_read(codec, 0x14, 0,
10093                                              AC_VERB_GET_PIN_SENSE, 0);
10094                 /* need to execute and sync at first */
10095                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10096                 /* check docking HP jack */
10097                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10098                                               AC_VERB_GET_PIN_SENSE, 0);
10099                 if (present & AC_PINSENSE_PRESENCE)
10100                         spec->jack_present = 1;
10101                 else
10102                         spec->jack_present = 0;
10103                 spec->sense_updated = 1;
10104         }
10105         /* unmute internal speaker only if both HPs are unplugged and
10106          * master switch is on
10107          */
10108         if (spec->jack_present)
10109                 mute = HDA_AMP_MUTE;
10110         else
10111                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10112         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10113                                  HDA_AMP_MUTE, mute);
10114 }
10115
10116 /* unsolicited event for HP jack sensing */
10117 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10118                                        unsigned int res)
10119 {
10120         if ((res >> 26) != ALC_HP_EVENT)
10121                 return;
10122         alc262_fujitsu_automute(codec, 1);
10123 }
10124
10125 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10126 {
10127         alc262_fujitsu_automute(codec, 1);
10128 }
10129
10130 /* bind volumes of both NID 0x0c and 0x0d */
10131 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10132         .ops = &snd_hda_bind_vol,
10133         .values = {
10134                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10135                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10136                 0
10137         },
10138 };
10139
10140 /* mute/unmute internal speaker according to the hp jack and mute state */
10141 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10142 {
10143         struct alc_spec *spec = codec->spec;
10144         unsigned int mute;
10145
10146         if (force || !spec->sense_updated) {
10147                 unsigned int present_int_hp;
10148                 /* need to execute and sync at first */
10149                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10150                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10151                                         AC_VERB_GET_PIN_SENSE, 0);
10152                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10153                 spec->sense_updated = 1;
10154         }
10155         if (spec->jack_present) {
10156                 /* mute internal speaker */
10157                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10158                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10159                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10160                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10161         } else {
10162                 /* unmute internal speaker if necessary */
10163                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10164                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10165                                          HDA_AMP_MUTE, mute);
10166                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10167                                          HDA_AMP_MUTE, mute);
10168         }
10169 }
10170
10171 /* unsolicited event for HP jack sensing */
10172 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10173                                        unsigned int res)
10174 {
10175         if ((res >> 26) != ALC_HP_EVENT)
10176                 return;
10177         alc262_lenovo_3000_automute(codec, 1);
10178 }
10179
10180 /* bind hp and internal speaker mute (with plug check) */
10181 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10182                                          struct snd_ctl_elem_value *ucontrol)
10183 {
10184         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10185         long *valp = ucontrol->value.integer.value;
10186         int change;
10187
10188         change = snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10189                                                  HDA_AMP_MUTE,
10190                                                  valp ? 0 : HDA_AMP_MUTE);
10191         change |= snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10192                                                  HDA_AMP_MUTE,
10193                                                  valp ? 0 : HDA_AMP_MUTE);
10194
10195         if (change)
10196                 alc262_fujitsu_automute(codec, 0);
10197         return change;
10198 }
10199
10200 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10201         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10202         {
10203                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10204                 .name = "Master Playback Switch",
10205                 .info = snd_hda_mixer_amp_switch_info,
10206                 .get = snd_hda_mixer_amp_switch_get,
10207                 .put = alc262_fujitsu_master_sw_put,
10208                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10209         },
10210         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10211         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10212         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10213         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10214         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10215         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10216         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10217         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10218         { } /* end */
10219 };
10220
10221 /* bind hp and internal speaker mute (with plug check) */
10222 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10223                                          struct snd_ctl_elem_value *ucontrol)
10224 {
10225         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10226         long *valp = ucontrol->value.integer.value;
10227         int change;
10228
10229         change = snd_hda_codec_amp_stereo(codec, 0x1b, HDA_OUTPUT, 0,
10230                                                  HDA_AMP_MUTE,
10231                                                  valp ? 0 : HDA_AMP_MUTE);
10232
10233         if (change)
10234                 alc262_lenovo_3000_automute(codec, 0);
10235         return change;
10236 }
10237
10238 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10239         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10240         {
10241                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10242                 .name = "Master Playback Switch",
10243                 .info = snd_hda_mixer_amp_switch_info,
10244                 .get = snd_hda_mixer_amp_switch_get,
10245                 .put = alc262_lenovo_3000_master_sw_put,
10246                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10247         },
10248         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10249         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10250         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10251         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10252         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10253         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10254         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10255         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10256         { } /* end */
10257 };
10258
10259 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10260         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10261         ALC262_HIPPO_MASTER_SWITCH,
10262         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10263         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10264         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10265         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10266         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10267         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10268         { } /* end */
10269 };
10270
10271 /* additional init verbs for Benq laptops */
10272 static struct hda_verb alc262_EAPD_verbs[] = {
10273         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10274         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10275         {}
10276 };
10277
10278 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10279         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10280         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10281
10282         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10283         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10284         {}
10285 };
10286
10287 /* Samsung Q1 Ultra Vista model setup */
10288 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10289         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10290         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10291         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10292         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10293         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10294         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10295         { } /* end */
10296 };
10297
10298 static struct hda_verb alc262_ultra_verbs[] = {
10299         /* output mixer */
10300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10301         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10302         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10303         /* speaker */
10304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10305         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10306         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10307         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10308         /* HP */
10309         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10310         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10311         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10312         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10313         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10314         /* internal mic */
10315         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10316         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10317         /* ADC, choose mic */
10318         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10319         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10320         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10321         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10326         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10327         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10328         {}
10329 };
10330
10331 /* mute/unmute internal speaker according to the hp jack and mute state */
10332 static void alc262_ultra_automute(struct hda_codec *codec)
10333 {
10334         struct alc_spec *spec = codec->spec;
10335         unsigned int mute;
10336
10337         mute = 0;
10338         /* auto-mute only when HP is used as HP */
10339         if (!spec->cur_mux[0]) {
10340                 unsigned int present;
10341                 /* need to execute and sync at first */
10342                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10343                 present = snd_hda_codec_read(codec, 0x15, 0,
10344                                              AC_VERB_GET_PIN_SENSE, 0);
10345                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10346                 if (spec->jack_present)
10347                         mute = HDA_AMP_MUTE;
10348         }
10349         /* mute/unmute internal speaker */
10350         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10351                                  HDA_AMP_MUTE, mute);
10352         /* mute/unmute HP */
10353         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10354                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10355 }
10356
10357 /* unsolicited event for HP jack sensing */
10358 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10359                                        unsigned int res)
10360 {
10361         if ((res >> 26) != ALC880_HP_EVENT)
10362                 return;
10363         alc262_ultra_automute(codec);
10364 }
10365
10366 static struct hda_input_mux alc262_ultra_capture_source = {
10367         .num_items = 2,
10368         .items = {
10369                 { "Mic", 0x1 },
10370                 { "Headphone", 0x7 },
10371         },
10372 };
10373
10374 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10375                                      struct snd_ctl_elem_value *ucontrol)
10376 {
10377         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10378         struct alc_spec *spec = codec->spec;
10379         int ret;
10380
10381         ret = alc_mux_enum_put(kcontrol, ucontrol);
10382         if (!ret)
10383                 return 0;
10384         /* reprogram the HP pin as mic or HP according to the input source */
10385         snd_hda_codec_write_cache(codec, 0x15, 0,
10386                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10387                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10388         alc262_ultra_automute(codec); /* mute/unmute HP */
10389         return ret;
10390 }
10391
10392 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10393         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10394         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10395         {
10396                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10397                 .name = "Capture Source",
10398                 .info = alc_mux_enum_info,
10399                 .get = alc_mux_enum_get,
10400                 .put = alc262_ultra_mux_enum_put,
10401         },
10402         { } /* end */
10403 };
10404
10405 /* add playback controls from the parsed DAC table */
10406 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10407                                              const struct auto_pin_cfg *cfg)
10408 {
10409         hda_nid_t nid;
10410         int err;
10411
10412         spec->multiout.num_dacs = 1;    /* only use one dac */
10413         spec->multiout.dac_nids = spec->private_dac_nids;
10414         spec->multiout.dac_nids[0] = 2;
10415
10416         nid = cfg->line_out_pins[0];
10417         if (nid) {
10418                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10419                                   "Front Playback Volume",
10420                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10421                 if (err < 0)
10422                         return err;
10423                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10424                                   "Front Playback Switch",
10425                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10426                 if (err < 0)
10427                         return err;
10428         }
10429
10430         nid = cfg->speaker_pins[0];
10431         if (nid) {
10432                 if (nid == 0x16) {
10433                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10434                                           "Speaker Playback Volume",
10435                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10436                                                               HDA_OUTPUT));
10437                         if (err < 0)
10438                                 return err;
10439                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10440                                           "Speaker Playback Switch",
10441                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10442                                                               HDA_OUTPUT));
10443                         if (err < 0)
10444                                 return err;
10445                 } else {
10446                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10447                                           "Speaker Playback Switch",
10448                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10449                                                               HDA_OUTPUT));
10450                         if (err < 0)
10451                                 return err;
10452                 }
10453         }
10454         nid = cfg->hp_pins[0];
10455         if (nid) {
10456                 /* spec->multiout.hp_nid = 2; */
10457                 if (nid == 0x16) {
10458                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10459                                           "Headphone Playback Volume",
10460                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10461                                                               HDA_OUTPUT));
10462                         if (err < 0)
10463                                 return err;
10464                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10465                                           "Headphone Playback Switch",
10466                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10467                                                               HDA_OUTPUT));
10468                         if (err < 0)
10469                                 return err;
10470                 } else {
10471                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10472                                           "Headphone Playback Switch",
10473                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10474                                                               HDA_OUTPUT));
10475                         if (err < 0)
10476                                 return err;
10477                 }
10478         }
10479         return 0;
10480 }
10481
10482 static int alc262_auto_create_analog_input_ctls(struct alc_spec *spec,
10483                                                 const struct auto_pin_cfg *cfg)
10484 {
10485         int err;
10486
10487         err = alc880_auto_create_analog_input_ctls(spec, cfg);
10488         if (err < 0)
10489                 return err;
10490         /* digital-mic input pin is excluded in alc880_auto_create..()
10491          * because it's under 0x18
10492          */
10493         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
10494             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
10495                 struct hda_input_mux *imux = &spec->private_imux[0];
10496                 imux->items[imux->num_items].label = "Int Mic";
10497                 imux->items[imux->num_items].index = 0x09;
10498                 imux->num_items++;
10499         }
10500         return 0;
10501 }
10502
10503
10504 /*
10505  * generic initialization of ADC, input mixers and output mixers
10506  */
10507 static struct hda_verb alc262_volume_init_verbs[] = {
10508         /*
10509          * Unmute ADC0-2 and set the default input to mic-in
10510          */
10511         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10512         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10513         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10514         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10515         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10516         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10517
10518         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10519          * mixer widget
10520          * Note: PASD motherboards uses the Line In 2 as the input for
10521          * front panel mic (mic 2)
10522          */
10523         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10524         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10525         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10526         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10527         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10528         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10529
10530         /*
10531          * Set up output mixers (0x0c - 0x0f)
10532          */
10533         /* set vol=0 to output mixers */
10534         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10535         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10536         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10537
10538         /* set up input amps for analog loopback */
10539         /* Amp Indices: DAC = 0, mixer = 1 */
10540         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10541         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10542         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10543         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10544         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10545         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10546
10547         /* FIXME: use matrix-type input source selection */
10548         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10549         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10550         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10551         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10552         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10553         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10554         /* Input mixer2 */
10555         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10556         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10557         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10558         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10559         /* Input mixer3 */
10560         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10561         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10562         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10563         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10564
10565         { }
10566 };
10567
10568 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10569         /*
10570          * Unmute ADC0-2 and set the default input to mic-in
10571          */
10572         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10573         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10574         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10575         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10576         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10577         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10578
10579         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10580          * mixer widget
10581          * Note: PASD motherboards uses the Line In 2 as the input for
10582          * front panel mic (mic 2)
10583          */
10584         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10585         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10586         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10587         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10588         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10589         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10590         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10591         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10592
10593         /*
10594          * Set up output mixers (0x0c - 0x0e)
10595          */
10596         /* set vol=0 to output mixers */
10597         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10598         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10599         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10600
10601         /* set up input amps for analog loopback */
10602         /* Amp Indices: DAC = 0, mixer = 1 */
10603         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10604         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10605         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10606         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10607         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10608         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10609
10610         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10611         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10612         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10613
10614         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10615         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10616
10617         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10618         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10619
10620         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10621         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10622         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10623         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10624         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10625
10626         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10627         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10628         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10629         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10630         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10631         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10632
10633
10634         /* FIXME: use matrix-type input source selection */
10635         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
10636         /* Input mixer1: only unmute Mic */
10637         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10638         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10639         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10640         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10641         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10642         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10643         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10644         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10645         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10646         /* Input mixer2 */
10647         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10648         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10649         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10650         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10651         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10652         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10653         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10654         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10655         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10656         /* Input mixer3 */
10657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10658         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10659         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10660         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10661         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10662         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10663         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
10664         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
10665         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
10666
10667         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10668
10669         { }
10670 };
10671
10672 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
10673         /*
10674          * Unmute ADC0-2 and set the default input to mic-in
10675          */
10676         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10677         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10678         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10679         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10680         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10681         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10682
10683         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10684          * mixer widget
10685          * Note: PASD motherboards uses the Line In 2 as the input for front
10686          * panel mic (mic 2)
10687          */
10688         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10689         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10690         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10691         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10692         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10693         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10694         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10695         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10696         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10697         /*
10698          * Set up output mixers (0x0c - 0x0e)
10699          */
10700         /* set vol=0 to output mixers */
10701         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10702         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10703         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10704
10705         /* set up input amps for analog loopback */
10706         /* Amp Indices: DAC = 0, mixer = 1 */
10707         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10708         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10709         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10710         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10711         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10712         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10713
10714
10715         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
10716         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
10717         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
10718         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
10719         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10720         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
10721         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
10722
10723         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10724         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10725
10726         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10727         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10728
10729         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
10730         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10731         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10732         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
10733         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10734         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10735
10736         /* FIXME: use matrix-type input source selection */
10737         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10738         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10739         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
10740         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
10741         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
10742         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
10743         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
10744         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
10745         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
10746         /* Input mixer2 */
10747         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10748         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10749         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10750         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10751         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10752         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10753         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10754         /* Input mixer3 */
10755         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10756         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10757         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
10758         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
10759         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
10760         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
10761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
10762
10763         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10764
10765         { }
10766 };
10767
10768 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
10769
10770         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
10771         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10772         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
10773
10774         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
10775         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
10776         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10777         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
10778
10779         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
10780         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10781         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10782         {}
10783 };
10784
10785
10786 #ifdef CONFIG_SND_HDA_POWER_SAVE
10787 #define alc262_loopbacks        alc880_loopbacks
10788 #endif
10789
10790 /* pcm configuration: identical with ALC880 */
10791 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
10792 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
10793 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
10794 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
10795
10796 /*
10797  * BIOS auto configuration
10798  */
10799 static int alc262_parse_auto_config(struct hda_codec *codec)
10800 {
10801         struct alc_spec *spec = codec->spec;
10802         int err;
10803         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
10804
10805         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10806                                            alc262_ignore);
10807         if (err < 0)
10808                 return err;
10809         if (!spec->autocfg.line_outs) {
10810                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
10811                         spec->multiout.max_channels = 2;
10812                         spec->no_analog = 1;
10813                         goto dig_only;
10814                 }
10815                 return 0; /* can't find valid BIOS pin config */
10816         }
10817         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
10818         if (err < 0)
10819                 return err;
10820         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
10821         if (err < 0)
10822                 return err;
10823
10824         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10825
10826  dig_only:
10827         if (spec->autocfg.dig_outs) {
10828                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
10829                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
10830         }
10831         if (spec->autocfg.dig_in_pin)
10832                 spec->dig_in_nid = ALC262_DIGIN_NID;
10833
10834         if (spec->kctls.list)
10835                 add_mixer(spec, spec->kctls.list);
10836
10837         add_verb(spec, alc262_volume_init_verbs);
10838         spec->num_mux_defs = 1;
10839         spec->input_mux = &spec->private_imux[0];
10840
10841         err = alc_auto_add_mic_boost(codec);
10842         if (err < 0)
10843                 return err;
10844
10845         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
10846
10847         return 1;
10848 }
10849
10850 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
10851 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
10852 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
10853 #define alc262_auto_init_input_src      alc882_auto_init_input_src
10854
10855
10856 /* init callback for auto-configuration model -- overriding the default init */
10857 static void alc262_auto_init(struct hda_codec *codec)
10858 {
10859         struct alc_spec *spec = codec->spec;
10860         alc262_auto_init_multi_out(codec);
10861         alc262_auto_init_hp_out(codec);
10862         alc262_auto_init_analog_input(codec);
10863         alc262_auto_init_input_src(codec);
10864         if (spec->unsol_event)
10865                 alc_inithook(codec);
10866 }
10867
10868 /*
10869  * configuration and preset
10870  */
10871 static const char *alc262_models[ALC262_MODEL_LAST] = {
10872         [ALC262_BASIC]          = "basic",
10873         [ALC262_HIPPO]          = "hippo",
10874         [ALC262_HIPPO_1]        = "hippo_1",
10875         [ALC262_FUJITSU]        = "fujitsu",
10876         [ALC262_HP_BPC]         = "hp-bpc",
10877         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
10878         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
10879         [ALC262_HP_RP5700]      = "hp-rp5700",
10880         [ALC262_BENQ_ED8]       = "benq",
10881         [ALC262_BENQ_T31]       = "benq-t31",
10882         [ALC262_SONY_ASSAMD]    = "sony-assamd",
10883         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
10884         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
10885         [ALC262_ULTRA]          = "ultra",
10886         [ALC262_LENOVO_3000]    = "lenovo-3000",
10887         [ALC262_NEC]            = "nec",
10888         [ALC262_TYAN]           = "tyan",
10889         [ALC262_AUTO]           = "auto",
10890 };
10891
10892 static struct snd_pci_quirk alc262_cfg_tbl[] = {
10893         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
10894         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
10895         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
10896                            ALC262_HP_BPC),
10897         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
10898                            ALC262_HP_BPC),
10899         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
10900                            ALC262_HP_BPC),
10901         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
10902         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
10903         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
10904         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
10905         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
10906         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
10907         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
10908         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
10909         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
10910         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
10911         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
10912         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
10913                       ALC262_HP_TC_T5735),
10914         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
10915         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10916         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
10917         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
10918         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
10919         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
10920         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
10921                            ALC262_SONY_ASSAMD),
10922         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
10923                       ALC262_TOSHIBA_RX1),
10924         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
10925         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
10926         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
10927         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
10928         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
10929                            ALC262_ULTRA),
10930         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
10931         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
10932         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
10933         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
10934         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
10935         {}
10936 };
10937
10938 static struct alc_config_preset alc262_presets[] = {
10939         [ALC262_BASIC] = {
10940                 .mixers = { alc262_base_mixer },
10941                 .init_verbs = { alc262_init_verbs },
10942                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10943                 .dac_nids = alc262_dac_nids,
10944                 .hp_nid = 0x03,
10945                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10946                 .channel_mode = alc262_modes,
10947                 .input_mux = &alc262_capture_source,
10948         },
10949         [ALC262_HIPPO] = {
10950                 .mixers = { alc262_hippo_mixer },
10951                 .init_verbs = { alc262_init_verbs, alc262_hippo_unsol_verbs},
10952                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10953                 .dac_nids = alc262_dac_nids,
10954                 .hp_nid = 0x03,
10955                 .dig_out_nid = ALC262_DIGOUT_NID,
10956                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10957                 .channel_mode = alc262_modes,
10958                 .input_mux = &alc262_capture_source,
10959                 .unsol_event = alc262_hippo_unsol_event,
10960                 .init_hook = alc262_hippo_init_hook,
10961         },
10962         [ALC262_HIPPO_1] = {
10963                 .mixers = { alc262_hippo1_mixer },
10964                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
10965                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10966                 .dac_nids = alc262_dac_nids,
10967                 .hp_nid = 0x02,
10968                 .dig_out_nid = ALC262_DIGOUT_NID,
10969                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10970                 .channel_mode = alc262_modes,
10971                 .input_mux = &alc262_capture_source,
10972                 .unsol_event = alc262_hippo_unsol_event,
10973                 .init_hook = alc262_hippo1_init_hook,
10974         },
10975         [ALC262_FUJITSU] = {
10976                 .mixers = { alc262_fujitsu_mixer },
10977                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
10978                                 alc262_fujitsu_unsol_verbs },
10979                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10980                 .dac_nids = alc262_dac_nids,
10981                 .hp_nid = 0x03,
10982                 .dig_out_nid = ALC262_DIGOUT_NID,
10983                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10984                 .channel_mode = alc262_modes,
10985                 .input_mux = &alc262_fujitsu_capture_source,
10986                 .unsol_event = alc262_fujitsu_unsol_event,
10987                 .init_hook = alc262_fujitsu_init_hook,
10988         },
10989         [ALC262_HP_BPC] = {
10990                 .mixers = { alc262_HP_BPC_mixer },
10991                 .init_verbs = { alc262_HP_BPC_init_verbs },
10992                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
10993                 .dac_nids = alc262_dac_nids,
10994                 .hp_nid = 0x03,
10995                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
10996                 .channel_mode = alc262_modes,
10997                 .input_mux = &alc262_HP_capture_source,
10998                 .unsol_event = alc262_hp_bpc_unsol_event,
10999                 .init_hook = alc262_hp_bpc_automute,
11000         },
11001         [ALC262_HP_BPC_D7000_WF] = {
11002                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11003                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11004                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11005                 .dac_nids = alc262_dac_nids,
11006                 .hp_nid = 0x03,
11007                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11008                 .channel_mode = alc262_modes,
11009                 .input_mux = &alc262_HP_D7000_capture_source,
11010                 .unsol_event = alc262_hp_wildwest_unsol_event,
11011                 .init_hook = alc262_hp_wildwest_automute,
11012         },
11013         [ALC262_HP_BPC_D7000_WL] = {
11014                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11015                             alc262_HP_BPC_WildWest_option_mixer },
11016                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11017                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11018                 .dac_nids = alc262_dac_nids,
11019                 .hp_nid = 0x03,
11020                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11021                 .channel_mode = alc262_modes,
11022                 .input_mux = &alc262_HP_D7000_capture_source,
11023                 .unsol_event = alc262_hp_wildwest_unsol_event,
11024                 .init_hook = alc262_hp_wildwest_automute,
11025         },
11026         [ALC262_HP_TC_T5735] = {
11027                 .mixers = { alc262_hp_t5735_mixer },
11028                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11029                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11030                 .dac_nids = alc262_dac_nids,
11031                 .hp_nid = 0x03,
11032                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11033                 .channel_mode = alc262_modes,
11034                 .input_mux = &alc262_capture_source,
11035                 .unsol_event = alc_automute_amp_unsol_event,
11036                 .init_hook = alc262_hp_t5735_init_hook,
11037         },
11038         [ALC262_HP_RP5700] = {
11039                 .mixers = { alc262_hp_rp5700_mixer },
11040                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11041                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11042                 .dac_nids = alc262_dac_nids,
11043                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11044                 .channel_mode = alc262_modes,
11045                 .input_mux = &alc262_hp_rp5700_capture_source,
11046         },
11047         [ALC262_BENQ_ED8] = {
11048                 .mixers = { alc262_base_mixer },
11049                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11050                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11051                 .dac_nids = alc262_dac_nids,
11052                 .hp_nid = 0x03,
11053                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11054                 .channel_mode = alc262_modes,
11055                 .input_mux = &alc262_capture_source,
11056         },
11057         [ALC262_SONY_ASSAMD] = {
11058                 .mixers = { alc262_sony_mixer },
11059                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11060                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11061                 .dac_nids = alc262_dac_nids,
11062                 .hp_nid = 0x02,
11063                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11064                 .channel_mode = alc262_modes,
11065                 .input_mux = &alc262_capture_source,
11066                 .unsol_event = alc262_hippo_unsol_event,
11067                 .init_hook = alc262_hippo_init_hook,
11068         },
11069         [ALC262_BENQ_T31] = {
11070                 .mixers = { alc262_benq_t31_mixer },
11071                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs, alc262_hippo_unsol_verbs },
11072                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11073                 .dac_nids = alc262_dac_nids,
11074                 .hp_nid = 0x03,
11075                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11076                 .channel_mode = alc262_modes,
11077                 .input_mux = &alc262_capture_source,
11078                 .unsol_event = alc262_hippo_unsol_event,
11079                 .init_hook = alc262_hippo_init_hook,
11080         },
11081         [ALC262_ULTRA] = {
11082                 .mixers = { alc262_ultra_mixer },
11083                 .cap_mixer = alc262_ultra_capture_mixer,
11084                 .init_verbs = { alc262_ultra_verbs },
11085                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11086                 .dac_nids = alc262_dac_nids,
11087                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11088                 .channel_mode = alc262_modes,
11089                 .input_mux = &alc262_ultra_capture_source,
11090                 .adc_nids = alc262_adc_nids, /* ADC0 */
11091                 .capsrc_nids = alc262_capsrc_nids,
11092                 .num_adc_nids = 1, /* single ADC */
11093                 .unsol_event = alc262_ultra_unsol_event,
11094                 .init_hook = alc262_ultra_automute,
11095         },
11096         [ALC262_LENOVO_3000] = {
11097                 .mixers = { alc262_lenovo_3000_mixer },
11098                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11099                                 alc262_lenovo_3000_unsol_verbs },
11100                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11101                 .dac_nids = alc262_dac_nids,
11102                 .hp_nid = 0x03,
11103                 .dig_out_nid = ALC262_DIGOUT_NID,
11104                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11105                 .channel_mode = alc262_modes,
11106                 .input_mux = &alc262_fujitsu_capture_source,
11107                 .unsol_event = alc262_lenovo_3000_unsol_event,
11108         },
11109         [ALC262_NEC] = {
11110                 .mixers = { alc262_nec_mixer },
11111                 .init_verbs = { alc262_nec_verbs },
11112                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11113                 .dac_nids = alc262_dac_nids,
11114                 .hp_nid = 0x03,
11115                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11116                 .channel_mode = alc262_modes,
11117                 .input_mux = &alc262_capture_source,
11118         },
11119         [ALC262_TOSHIBA_S06] = {
11120                 .mixers = { alc262_toshiba_s06_mixer },
11121                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11122                                                         alc262_eapd_verbs },
11123                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11124                 .capsrc_nids = alc262_dmic_capsrc_nids,
11125                 .dac_nids = alc262_dac_nids,
11126                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11127                 .num_adc_nids = 1, /* single ADC */
11128                 .dig_out_nid = ALC262_DIGOUT_NID,
11129                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11130                 .channel_mode = alc262_modes,
11131                 .input_mux = &alc262_dmic_capture_source,
11132                 .unsol_event = alc262_toshiba_s06_unsol_event,
11133                 .init_hook = alc262_toshiba_s06_init_hook,
11134         },
11135         [ALC262_TOSHIBA_RX1] = {
11136                 .mixers = { alc262_toshiba_rx1_mixer },
11137                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11138                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11139                 .dac_nids = alc262_dac_nids,
11140                 .hp_nid = 0x03,
11141                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11142                 .channel_mode = alc262_modes,
11143                 .input_mux = &alc262_capture_source,
11144                 .unsol_event = alc262_hippo_unsol_event,
11145                 .init_hook = alc262_hippo_init_hook,
11146         },
11147         [ALC262_TYAN] = {
11148                 .mixers = { alc262_tyan_mixer },
11149                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11150                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11151                 .dac_nids = alc262_dac_nids,
11152                 .hp_nid = 0x02,
11153                 .dig_out_nid = ALC262_DIGOUT_NID,
11154                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11155                 .channel_mode = alc262_modes,
11156                 .input_mux = &alc262_capture_source,
11157                 .unsol_event = alc_automute_amp_unsol_event,
11158                 .init_hook = alc262_tyan_init_hook,
11159         },
11160 };
11161
11162 static int patch_alc262(struct hda_codec *codec)
11163 {
11164         struct alc_spec *spec;
11165         int board_config;
11166         int err;
11167
11168         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11169         if (spec == NULL)
11170                 return -ENOMEM;
11171
11172         codec->spec = spec;
11173 #if 0
11174         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11175          * under-run
11176          */
11177         {
11178         int tmp;
11179         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11180         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11181         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11182         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11183         }
11184 #endif
11185
11186         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11187
11188         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11189                                                   alc262_models,
11190                                                   alc262_cfg_tbl);
11191
11192         if (board_config < 0) {
11193                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
11194                        "trying auto-probe from BIOS...\n", codec->chip_name);
11195                 board_config = ALC262_AUTO;
11196         }
11197
11198         if (board_config == ALC262_AUTO) {
11199                 /* automatic parse from the BIOS config */
11200                 err = alc262_parse_auto_config(codec);
11201                 if (err < 0) {
11202                         alc_free(codec);
11203                         return err;
11204                 } else if (!err) {
11205                         printk(KERN_INFO
11206                                "hda_codec: Cannot set up configuration "
11207                                "from BIOS.  Using base mode...\n");
11208                         board_config = ALC262_BASIC;
11209                 }
11210         }
11211
11212         if (!spec->no_analog) {
11213                 err = snd_hda_attach_beep_device(codec, 0x1);
11214                 if (err < 0) {
11215                         alc_free(codec);
11216                         return err;
11217                 }
11218         }
11219
11220         if (board_config != ALC262_AUTO)
11221                 setup_preset(spec, &alc262_presets[board_config]);
11222
11223         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11224         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11225
11226         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11227         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11228
11229         if (!spec->adc_nids && spec->input_mux) {
11230                 int i;
11231                 /* check whether the digital-mic has to be supported */
11232                 for (i = 0; i < spec->input_mux->num_items; i++) {
11233                         if (spec->input_mux->items[i].index >= 9)
11234                                 break;
11235                 }
11236                 if (i < spec->input_mux->num_items) {
11237                         /* use only ADC0 */
11238                         spec->adc_nids = alc262_dmic_adc_nids;
11239                         spec->num_adc_nids = 1;
11240                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11241                 } else {
11242                         /* all analog inputs */
11243                         /* check whether NID 0x07 is valid */
11244                         unsigned int wcap = get_wcaps(codec, 0x07);
11245
11246                         /* get type */
11247                         wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
11248                         if (wcap != AC_WID_AUD_IN) {
11249                                 spec->adc_nids = alc262_adc_nids_alt;
11250                                 spec->num_adc_nids =
11251                                         ARRAY_SIZE(alc262_adc_nids_alt);
11252                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11253                         } else {
11254                                 spec->adc_nids = alc262_adc_nids;
11255                                 spec->num_adc_nids =
11256                                         ARRAY_SIZE(alc262_adc_nids);
11257                                 spec->capsrc_nids = alc262_capsrc_nids;
11258                         }
11259                 }
11260         }
11261         if (!spec->cap_mixer && !spec->no_analog)
11262                 set_capture_mixer(spec);
11263         if (!spec->no_analog)
11264                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11265
11266         spec->vmaster_nid = 0x0c;
11267
11268         codec->patch_ops = alc_patch_ops;
11269         if (board_config == ALC262_AUTO)
11270                 spec->init_hook = alc262_auto_init;
11271 #ifdef CONFIG_SND_HDA_POWER_SAVE
11272         if (!spec->loopback.amplist)
11273                 spec->loopback.amplist = alc262_loopbacks;
11274 #endif
11275         codec->proc_widget_hook = print_realtek_coef;
11276
11277         return 0;
11278 }
11279
11280 /*
11281  *  ALC268 channel source setting (2 channel)
11282  */
11283 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11284 #define alc268_modes            alc260_modes
11285
11286 static hda_nid_t alc268_dac_nids[2] = {
11287         /* front, hp */
11288         0x02, 0x03
11289 };
11290
11291 static hda_nid_t alc268_adc_nids[2] = {
11292         /* ADC0-1 */
11293         0x08, 0x07
11294 };
11295
11296 static hda_nid_t alc268_adc_nids_alt[1] = {
11297         /* ADC0 */
11298         0x08
11299 };
11300
11301 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11302
11303 static struct snd_kcontrol_new alc268_base_mixer[] = {
11304         /* output mixer control */
11305         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11306         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11307         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11308         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11309         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11310         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11311         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11312         { }
11313 };
11314
11315 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11316         /* output mixer control */
11317         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11318         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11319         ALC262_HIPPO_MASTER_SWITCH,
11320         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11321         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11322         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11323         { }
11324 };
11325
11326 /* bind Beep switches of both NID 0x0f and 0x10 */
11327 static struct hda_bind_ctls alc268_bind_beep_sw = {
11328         .ops = &snd_hda_bind_sw,
11329         .values = {
11330                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11331                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11332                 0
11333         },
11334 };
11335
11336 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11337         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11338         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11339         { }
11340 };
11341
11342 static struct hda_verb alc268_eapd_verbs[] = {
11343         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11344         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11345         { }
11346 };
11347
11348 /* Toshiba specific */
11349 static struct hda_verb alc268_toshiba_verbs[] = {
11350         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11351         { } /* end */
11352 };
11353
11354 static struct hda_input_mux alc268_acer_lc_capture_source = {
11355         .num_items = 2,
11356         .items = {
11357                 { "i-Mic", 0x6 },
11358                 { "E-Mic", 0x0 },
11359         },
11360 };
11361
11362 /* Acer specific */
11363 /* bind volumes of both NID 0x02 and 0x03 */
11364 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11365         .ops = &snd_hda_bind_vol,
11366         .values = {
11367                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11368                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11369                 0
11370         },
11371 };
11372
11373 /* mute/unmute internal speaker according to the hp jack and mute state */
11374 static void alc268_acer_automute(struct hda_codec *codec, int force)
11375 {
11376         struct alc_spec *spec = codec->spec;
11377         unsigned int mute;
11378
11379         if (force || !spec->sense_updated) {
11380                 unsigned int present;
11381                 present = snd_hda_codec_read(codec, 0x14, 0,
11382                                          AC_VERB_GET_PIN_SENSE, 0);
11383                 spec->jack_present = (present & 0x80000000) != 0;
11384                 spec->sense_updated = 1;
11385         }
11386         if (spec->jack_present)
11387                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11388         else /* unmute internal speaker if necessary */
11389                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11390         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11391                                  HDA_AMP_MUTE, mute);
11392 }
11393
11394
11395 /* bind hp and internal speaker mute (with plug check) */
11396 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11397                                      struct snd_ctl_elem_value *ucontrol)
11398 {
11399         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11400         long *valp = ucontrol->value.integer.value;
11401         int change;
11402
11403         change = snd_hda_codec_amp_update(codec, 0x14, 0, HDA_OUTPUT, 0,
11404                                           HDA_AMP_MUTE,
11405                                           valp[0] ? 0 : HDA_AMP_MUTE);
11406         change |= snd_hda_codec_amp_update(codec, 0x14, 1, HDA_OUTPUT, 0,
11407                                            HDA_AMP_MUTE,
11408                                            valp[1] ? 0 : HDA_AMP_MUTE);
11409         if (change)
11410                 alc268_acer_automute(codec, 0);
11411         return change;
11412 }
11413
11414 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11415         /* output mixer control */
11416         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11417         {
11418                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11419                 .name = "Master Playback Switch",
11420                 .info = snd_hda_mixer_amp_switch_info,
11421                 .get = snd_hda_mixer_amp_switch_get,
11422                 .put = alc268_acer_master_sw_put,
11423                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11424         },
11425         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11426         { }
11427 };
11428
11429 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11430         /* output mixer control */
11431         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11432         {
11433                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11434                 .name = "Master Playback Switch",
11435                 .info = snd_hda_mixer_amp_switch_info,
11436                 .get = snd_hda_mixer_amp_switch_get,
11437                 .put = alc268_acer_master_sw_put,
11438                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11439         },
11440         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11441         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11442         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11443         { }
11444 };
11445
11446 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11447         /* output mixer control */
11448         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11449         {
11450                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11451                 .name = "Master Playback Switch",
11452                 .info = snd_hda_mixer_amp_switch_info,
11453                 .get = snd_hda_mixer_amp_switch_get,
11454                 .put = alc268_acer_master_sw_put,
11455                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11456         },
11457         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11458         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11459         { }
11460 };
11461
11462 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11463         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11464         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11465         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11466         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11467         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11468         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11469         { }
11470 };
11471
11472 static struct hda_verb alc268_acer_verbs[] = {
11473         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11474         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11475         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11476         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11477         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11478         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11479         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11480         { }
11481 };
11482
11483 /* unsolicited event for HP jack sensing */
11484 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
11485 #define alc268_toshiba_init_hook        alc262_hippo_init_hook
11486
11487 static void alc268_acer_unsol_event(struct hda_codec *codec,
11488                                        unsigned int res)
11489 {
11490         if ((res >> 26) != ALC880_HP_EVENT)
11491                 return;
11492         alc268_acer_automute(codec, 1);
11493 }
11494
11495 static void alc268_acer_init_hook(struct hda_codec *codec)
11496 {
11497         alc268_acer_automute(codec, 1);
11498 }
11499
11500 /* toggle speaker-output according to the hp-jack state */
11501 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11502 {
11503         unsigned int present;
11504         unsigned char bits;
11505
11506         present = snd_hda_codec_read(codec, 0x15, 0,
11507                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11508         bits = present ? AMP_IN_MUTE(0) : 0;
11509         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11510                                 AMP_IN_MUTE(0), bits);
11511         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11512                                 AMP_IN_MUTE(0), bits);
11513 }
11514
11515
11516 static void alc268_acer_mic_automute(struct hda_codec *codec)
11517 {
11518         unsigned int present;
11519
11520         present = snd_hda_codec_read(codec, 0x18, 0,
11521                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11522         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11523                             present ? 0x0 : 0x6);
11524 }
11525
11526 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11527                                     unsigned int res)
11528 {
11529         if ((res >> 26) == ALC880_HP_EVENT)
11530                 alc268_aspire_one_speaker_automute(codec);
11531         if ((res >> 26) == ALC880_MIC_EVENT)
11532                 alc268_acer_mic_automute(codec);
11533 }
11534
11535 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11536 {
11537         alc268_aspire_one_speaker_automute(codec);
11538         alc268_acer_mic_automute(codec);
11539 }
11540
11541 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11542         /* output mixer control */
11543         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11544         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11545         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11546         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11547         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11548         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11549         { }
11550 };
11551
11552 static struct hda_verb alc268_dell_verbs[] = {
11553         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11554         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11555         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11556         { }
11557 };
11558
11559 /* mute/unmute internal speaker according to the hp jack and mute state */
11560 static void alc268_dell_init_hook(struct hda_codec *codec)
11561 {
11562         struct alc_spec *spec = codec->spec;
11563
11564         spec->autocfg.hp_pins[0] = 0x15;
11565         spec->autocfg.speaker_pins[0] = 0x14;
11566         alc_automute_pin(codec);
11567 }
11568
11569 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11570         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11571         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11572         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11573         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11574         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11575         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11576         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11577         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11578         { }
11579 };
11580
11581 static struct hda_verb alc267_quanta_il1_verbs[] = {
11582         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11583         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11584         { }
11585 };
11586
11587 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11588 {
11589         unsigned int present;
11590
11591         present = snd_hda_codec_read(codec, 0x18, 0,
11592                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11593         snd_hda_codec_write(codec, 0x23, 0,
11594                             AC_VERB_SET_CONNECT_SEL,
11595                             present ? 0x00 : 0x01);
11596 }
11597
11598 static void alc267_quanta_il1_init_hook(struct hda_codec *codec)
11599 {
11600         struct alc_spec *spec = codec->spec;
11601
11602         spec->autocfg.hp_pins[0] = 0x15;
11603         spec->autocfg.speaker_pins[0] = 0x14;
11604         alc_automute_pin(codec);
11605         alc267_quanta_il1_mic_automute(codec);
11606 }
11607
11608 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11609                                            unsigned int res)
11610 {
11611         switch (res >> 26) {
11612         case ALC880_MIC_EVENT:
11613                 alc267_quanta_il1_mic_automute(codec);
11614                 break;
11615         default:
11616                 alc_sku_unsol_event(codec, res);
11617                 break;
11618         }
11619 }
11620
11621 /*
11622  * generic initialization of ADC, input mixers and output mixers
11623  */
11624 static struct hda_verb alc268_base_init_verbs[] = {
11625         /* Unmute DAC0-1 and set vol = 0 */
11626         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11627         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11628
11629         /*
11630          * Set up output mixers (0x0c - 0x0e)
11631          */
11632         /* set vol=0 to output mixers */
11633         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11634         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11635
11636         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11637         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11638
11639         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11640         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11641         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11642         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11643         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11644         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11645         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11646         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11647
11648         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11649         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11650         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11651         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11653
11654         /* set PCBEEP vol = 0, mute connections */
11655         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11656         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11657         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11658
11659         /* Unmute Selector 23h,24h and set the default input to mic-in */
11660
11661         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
11662         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11663         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
11664         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11665
11666         { }
11667 };
11668
11669 /*
11670  * generic initialization of ADC, input mixers and output mixers
11671  */
11672 static struct hda_verb alc268_volume_init_verbs[] = {
11673         /* set output DAC */
11674         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11675         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11676
11677         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11678         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11679         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11680         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11681         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11682
11683         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11684         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11685         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11686
11687         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11688         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11689
11690         /* set PCBEEP vol = 0, mute connections */
11691         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11692         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11693         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11694
11695         { }
11696 };
11697
11698 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
11699         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11700         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11701         {
11702                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11703                 /* The multiple "Capture Source" controls confuse alsamixer
11704                  * So call somewhat different..
11705                  */
11706                 /* .name = "Capture Source", */
11707                 .name = "Input Source",
11708                 .count = 1,
11709                 .info = alc_mux_enum_info,
11710                 .get = alc_mux_enum_get,
11711                 .put = alc_mux_enum_put,
11712         },
11713         { } /* end */
11714 };
11715
11716 static struct snd_kcontrol_new alc268_capture_mixer[] = {
11717         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11718         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
11719         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
11720         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
11721         {
11722                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11723                 /* The multiple "Capture Source" controls confuse alsamixer
11724                  * So call somewhat different..
11725                  */
11726                 /* .name = "Capture Source", */
11727                 .name = "Input Source",
11728                 .count = 2,
11729                 .info = alc_mux_enum_info,
11730                 .get = alc_mux_enum_get,
11731                 .put = alc_mux_enum_put,
11732         },
11733         { } /* end */
11734 };
11735
11736 static struct hda_input_mux alc268_capture_source = {
11737         .num_items = 4,
11738         .items = {
11739                 { "Mic", 0x0 },
11740                 { "Front Mic", 0x1 },
11741                 { "Line", 0x2 },
11742                 { "CD", 0x3 },
11743         },
11744 };
11745
11746 static struct hda_input_mux alc268_acer_capture_source = {
11747         .num_items = 3,
11748         .items = {
11749                 { "Mic", 0x0 },
11750                 { "Internal Mic", 0x1 },
11751                 { "Line", 0x2 },
11752         },
11753 };
11754
11755 static struct hda_input_mux alc268_acer_dmic_capture_source = {
11756         .num_items = 3,
11757         .items = {
11758                 { "Mic", 0x0 },
11759                 { "Internal Mic", 0x6 },
11760                 { "Line", 0x2 },
11761         },
11762 };
11763
11764 #ifdef CONFIG_SND_DEBUG
11765 static struct snd_kcontrol_new alc268_test_mixer[] = {
11766         /* Volume widgets */
11767         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11768         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11769         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
11770         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
11771         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
11772         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
11773         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
11774         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
11775         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
11776         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
11777         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
11778         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
11779         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
11780         /* The below appears problematic on some hardwares */
11781         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
11782         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11783         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
11784         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
11785         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
11786
11787         /* Modes for retasking pin widgets */
11788         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
11789         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
11790         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
11791         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
11792
11793         /* Controls for GPIO pins, assuming they are configured as outputs */
11794         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
11795         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
11796         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
11797         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
11798
11799         /* Switches to allow the digital SPDIF output pin to be enabled.
11800          * The ALC268 does not have an SPDIF input.
11801          */
11802         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
11803
11804         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
11805          * this output to turn on an external amplifier.
11806          */
11807         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
11808         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
11809
11810         { } /* end */
11811 };
11812 #endif
11813
11814 /* create input playback/capture controls for the given pin */
11815 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
11816                                     const char *ctlname, int idx)
11817 {
11818         char name[32];
11819         hda_nid_t dac;
11820         int err;
11821
11822         sprintf(name, "%s Playback Volume", ctlname);
11823         switch (nid) {
11824         case 0x14:
11825         case 0x16:
11826                 dac = 0x02;
11827                 break;
11828         case 0x15:
11829                 dac = 0x03;
11830                 break;
11831         default:
11832                 return 0;
11833         }
11834         if (spec->multiout.dac_nids[0] != dac &&
11835             spec->multiout.dac_nids[1] != dac) {
11836                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
11837                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
11838                                                       HDA_OUTPUT));
11839                 if (err < 0)
11840                         return err;
11841                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
11842         }
11843
11844         sprintf(name, "%s Playback Switch", ctlname);
11845         if (nid != 0x16)
11846                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11847                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
11848         else /* mono */
11849                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
11850                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
11851         if (err < 0)
11852                 return err;
11853         return 0;
11854 }
11855
11856 /* add playback controls from the parsed DAC table */
11857 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
11858                                              const struct auto_pin_cfg *cfg)
11859 {
11860         hda_nid_t nid;
11861         int err;
11862
11863         spec->multiout.dac_nids = spec->private_dac_nids;
11864
11865         nid = cfg->line_out_pins[0];
11866         if (nid) {
11867                 const char *name;
11868                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11869                         name = "Speaker";
11870                 else
11871                         name = "Front";
11872                 err = alc268_new_analog_output(spec, nid, name, 0);
11873                 if (err < 0)
11874                         return err;
11875         }
11876
11877         nid = cfg->speaker_pins[0];
11878         if (nid == 0x1d) {
11879                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
11880                                   "Speaker Playback Volume",
11881                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
11882                 if (err < 0)
11883                         return err;
11884         } else {
11885                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
11886                 if (err < 0)
11887                         return err;
11888         }
11889         nid = cfg->hp_pins[0];
11890         if (nid) {
11891                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
11892                 if (err < 0)
11893                         return err;
11894         }
11895
11896         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
11897         if (nid == 0x16) {
11898                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
11899                                   "Mono Playback Switch",
11900                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
11901                 if (err < 0)
11902                         return err;
11903         }
11904         return 0;
11905 }
11906
11907 /* create playback/capture controls for input pins */
11908 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
11909                                                 const struct auto_pin_cfg *cfg)
11910 {
11911         struct hda_input_mux *imux = &spec->private_imux[0];
11912         int i, idx1;
11913
11914         for (i = 0; i < AUTO_PIN_LAST; i++) {
11915                 switch(cfg->input_pins[i]) {
11916                 case 0x18:
11917                         idx1 = 0;       /* Mic 1 */
11918                         break;
11919                 case 0x19:
11920                         idx1 = 1;       /* Mic 2 */
11921                         break;
11922                 case 0x1a:
11923                         idx1 = 2;       /* Line In */
11924                         break;
11925                 case 0x1c:
11926                         idx1 = 3;       /* CD */
11927                         break;
11928                 case 0x12:
11929                 case 0x13:
11930                         idx1 = 6;       /* digital mics */
11931                         break;
11932                 default:
11933                         continue;
11934                 }
11935                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
11936                 imux->items[imux->num_items].index = idx1;
11937                 imux->num_items++;
11938         }
11939         return 0;
11940 }
11941
11942 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
11943 {
11944         struct alc_spec *spec = codec->spec;
11945         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11946         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11947         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11948         unsigned int    dac_vol1, dac_vol2;
11949
11950         if (speaker_nid) {
11951                 snd_hda_codec_write(codec, speaker_nid, 0,
11952                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
11953                 snd_hda_codec_write(codec, 0x0f, 0,
11954                                     AC_VERB_SET_AMP_GAIN_MUTE,
11955                                     AMP_IN_UNMUTE(1));
11956                 snd_hda_codec_write(codec, 0x10, 0,
11957                                     AC_VERB_SET_AMP_GAIN_MUTE,
11958                                     AMP_IN_UNMUTE(1));
11959         } else {
11960                 snd_hda_codec_write(codec, 0x0f, 0,
11961                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11962                 snd_hda_codec_write(codec, 0x10, 0,
11963                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
11964         }
11965
11966         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
11967         if (line_nid == 0x14)
11968                 dac_vol2 = AMP_OUT_ZERO;
11969         else if (line_nid == 0x15)
11970                 dac_vol1 = AMP_OUT_ZERO;
11971         if (hp_nid == 0x14)
11972                 dac_vol2 = AMP_OUT_ZERO;
11973         else if (hp_nid == 0x15)
11974                 dac_vol1 = AMP_OUT_ZERO;
11975         if (line_nid != 0x16 || hp_nid != 0x16 ||
11976             spec->autocfg.line_out_pins[1] != 0x16 ||
11977             spec->autocfg.line_out_pins[2] != 0x16)
11978                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
11979
11980         snd_hda_codec_write(codec, 0x02, 0,
11981                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
11982         snd_hda_codec_write(codec, 0x03, 0,
11983                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
11984 }
11985
11986 /* pcm configuration: identical with ALC880 */
11987 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
11988 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
11989 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
11990 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
11991
11992 /*
11993  * BIOS auto configuration
11994  */
11995 static int alc268_parse_auto_config(struct hda_codec *codec)
11996 {
11997         struct alc_spec *spec = codec->spec;
11998         int err;
11999         static hda_nid_t alc268_ignore[] = { 0 };
12000
12001         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12002                                            alc268_ignore);
12003         if (err < 0)
12004                 return err;
12005         if (!spec->autocfg.line_outs) {
12006                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12007                         spec->multiout.max_channels = 2;
12008                         spec->no_analog = 1;
12009                         goto dig_only;
12010                 }
12011                 return 0; /* can't find valid BIOS pin config */
12012         }
12013         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12014         if (err < 0)
12015                 return err;
12016         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
12017         if (err < 0)
12018                 return err;
12019
12020         spec->multiout.max_channels = 2;
12021
12022  dig_only:
12023         /* digital only support output */
12024         if (spec->autocfg.dig_outs) {
12025                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12026                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12027         }
12028         if (spec->kctls.list)
12029                 add_mixer(spec, spec->kctls.list);
12030
12031         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12032                 add_mixer(spec, alc268_beep_mixer);
12033
12034         add_verb(spec, alc268_volume_init_verbs);
12035         spec->num_mux_defs = 1;
12036         spec->input_mux = &spec->private_imux[0];
12037
12038         err = alc_auto_add_mic_boost(codec);
12039         if (err < 0)
12040                 return err;
12041
12042         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12043
12044         return 1;
12045 }
12046
12047 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12048 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12049 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12050
12051 /* init callback for auto-configuration model -- overriding the default init */
12052 static void alc268_auto_init(struct hda_codec *codec)
12053 {
12054         struct alc_spec *spec = codec->spec;
12055         alc268_auto_init_multi_out(codec);
12056         alc268_auto_init_hp_out(codec);
12057         alc268_auto_init_mono_speaker_out(codec);
12058         alc268_auto_init_analog_input(codec);
12059         if (spec->unsol_event)
12060                 alc_inithook(codec);
12061 }
12062
12063 /*
12064  * configuration and preset
12065  */
12066 static const char *alc268_models[ALC268_MODEL_LAST] = {
12067         [ALC267_QUANTA_IL1]     = "quanta-il1",
12068         [ALC268_3ST]            = "3stack",
12069         [ALC268_TOSHIBA]        = "toshiba",
12070         [ALC268_ACER]           = "acer",
12071         [ALC268_ACER_DMIC]      = "acer-dmic",
12072         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12073         [ALC268_DELL]           = "dell",
12074         [ALC268_ZEPTO]          = "zepto",
12075 #ifdef CONFIG_SND_DEBUG
12076         [ALC268_TEST]           = "test",
12077 #endif
12078         [ALC268_AUTO]           = "auto",
12079 };
12080
12081 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12082         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12083         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12084         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12085         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12086         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12087         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12088                                                 ALC268_ACER_ASPIRE_ONE),
12089         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12090         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12091         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12092                            ALC268_TOSHIBA),
12093         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12094         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12095         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12096                            ALC268_TOSHIBA),
12097         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12098         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12099         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12100         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12101         {}
12102 };
12103
12104 static struct alc_config_preset alc268_presets[] = {
12105         [ALC267_QUANTA_IL1] = {
12106                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12107                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12108                                 alc267_quanta_il1_verbs },
12109                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12110                 .dac_nids = alc268_dac_nids,
12111                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12112                 .adc_nids = alc268_adc_nids_alt,
12113                 .hp_nid = 0x03,
12114                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12115                 .channel_mode = alc268_modes,
12116                 .input_mux = &alc268_capture_source,
12117                 .unsol_event = alc267_quanta_il1_unsol_event,
12118                 .init_hook = alc267_quanta_il1_init_hook,
12119         },
12120         [ALC268_3ST] = {
12121                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12122                             alc268_beep_mixer },
12123                 .init_verbs = { alc268_base_init_verbs },
12124                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12125                 .dac_nids = alc268_dac_nids,
12126                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12127                 .adc_nids = alc268_adc_nids_alt,
12128                 .capsrc_nids = alc268_capsrc_nids,
12129                 .hp_nid = 0x03,
12130                 .dig_out_nid = ALC268_DIGOUT_NID,
12131                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12132                 .channel_mode = alc268_modes,
12133                 .input_mux = &alc268_capture_source,
12134         },
12135         [ALC268_TOSHIBA] = {
12136                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12137                             alc268_beep_mixer },
12138                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12139                                 alc268_toshiba_verbs },
12140                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12141                 .dac_nids = alc268_dac_nids,
12142                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12143                 .adc_nids = alc268_adc_nids_alt,
12144                 .capsrc_nids = alc268_capsrc_nids,
12145                 .hp_nid = 0x03,
12146                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12147                 .channel_mode = alc268_modes,
12148                 .input_mux = &alc268_capture_source,
12149                 .unsol_event = alc268_toshiba_unsol_event,
12150                 .init_hook = alc268_toshiba_init_hook,
12151         },
12152         [ALC268_ACER] = {
12153                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12154                             alc268_beep_mixer },
12155                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12156                                 alc268_acer_verbs },
12157                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12158                 .dac_nids = alc268_dac_nids,
12159                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12160                 .adc_nids = alc268_adc_nids_alt,
12161                 .capsrc_nids = alc268_capsrc_nids,
12162                 .hp_nid = 0x02,
12163                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12164                 .channel_mode = alc268_modes,
12165                 .input_mux = &alc268_acer_capture_source,
12166                 .unsol_event = alc268_acer_unsol_event,
12167                 .init_hook = alc268_acer_init_hook,
12168         },
12169         [ALC268_ACER_DMIC] = {
12170                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12171                             alc268_beep_mixer },
12172                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12173                                 alc268_acer_verbs },
12174                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12175                 .dac_nids = alc268_dac_nids,
12176                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12177                 .adc_nids = alc268_adc_nids_alt,
12178                 .capsrc_nids = alc268_capsrc_nids,
12179                 .hp_nid = 0x02,
12180                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12181                 .channel_mode = alc268_modes,
12182                 .input_mux = &alc268_acer_dmic_capture_source,
12183                 .unsol_event = alc268_acer_unsol_event,
12184                 .init_hook = alc268_acer_init_hook,
12185         },
12186         [ALC268_ACER_ASPIRE_ONE] = {
12187                 .mixers = { alc268_acer_aspire_one_mixer,
12188                             alc268_beep_mixer,
12189                             alc268_capture_alt_mixer },
12190                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12191                                 alc268_acer_aspire_one_verbs },
12192                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12193                 .dac_nids = alc268_dac_nids,
12194                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12195                 .adc_nids = alc268_adc_nids_alt,
12196                 .capsrc_nids = alc268_capsrc_nids,
12197                 .hp_nid = 0x03,
12198                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12199                 .channel_mode = alc268_modes,
12200                 .input_mux = &alc268_acer_lc_capture_source,
12201                 .unsol_event = alc268_acer_lc_unsol_event,
12202                 .init_hook = alc268_acer_lc_init_hook,
12203         },
12204         [ALC268_DELL] = {
12205                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12206                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12207                                 alc268_dell_verbs },
12208                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12209                 .dac_nids = alc268_dac_nids,
12210                 .hp_nid = 0x02,
12211                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12212                 .channel_mode = alc268_modes,
12213                 .unsol_event = alc_sku_unsol_event,
12214                 .init_hook = alc268_dell_init_hook,
12215                 .input_mux = &alc268_capture_source,
12216         },
12217         [ALC268_ZEPTO] = {
12218                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12219                             alc268_beep_mixer },
12220                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12221                                 alc268_toshiba_verbs },
12222                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12223                 .dac_nids = alc268_dac_nids,
12224                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12225                 .adc_nids = alc268_adc_nids_alt,
12226                 .capsrc_nids = alc268_capsrc_nids,
12227                 .hp_nid = 0x03,
12228                 .dig_out_nid = ALC268_DIGOUT_NID,
12229                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12230                 .channel_mode = alc268_modes,
12231                 .input_mux = &alc268_capture_source,
12232                 .unsol_event = alc268_toshiba_unsol_event,
12233                 .init_hook = alc268_toshiba_init_hook
12234         },
12235 #ifdef CONFIG_SND_DEBUG
12236         [ALC268_TEST] = {
12237                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12238                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12239                                 alc268_volume_init_verbs },
12240                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12241                 .dac_nids = alc268_dac_nids,
12242                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12243                 .adc_nids = alc268_adc_nids_alt,
12244                 .capsrc_nids = alc268_capsrc_nids,
12245                 .hp_nid = 0x03,
12246                 .dig_out_nid = ALC268_DIGOUT_NID,
12247                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12248                 .channel_mode = alc268_modes,
12249                 .input_mux = &alc268_capture_source,
12250         },
12251 #endif
12252 };
12253
12254 static int patch_alc268(struct hda_codec *codec)
12255 {
12256         struct alc_spec *spec;
12257         int board_config;
12258         int i, has_beep, err;
12259
12260         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12261         if (spec == NULL)
12262                 return -ENOMEM;
12263
12264         codec->spec = spec;
12265
12266         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12267                                                   alc268_models,
12268                                                   alc268_cfg_tbl);
12269
12270         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12271                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
12272                        "trying auto-probe from BIOS...\n", codec->chip_name);
12273                 board_config = ALC268_AUTO;
12274         }
12275
12276         if (board_config == ALC268_AUTO) {
12277                 /* automatic parse from the BIOS config */
12278                 err = alc268_parse_auto_config(codec);
12279                 if (err < 0) {
12280                         alc_free(codec);
12281                         return err;
12282                 } else if (!err) {
12283                         printk(KERN_INFO
12284                                "hda_codec: Cannot set up configuration "
12285                                "from BIOS.  Using base mode...\n");
12286                         board_config = ALC268_3ST;
12287                 }
12288         }
12289
12290         if (board_config != ALC268_AUTO)
12291                 setup_preset(spec, &alc268_presets[board_config]);
12292
12293         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12294         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12295         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12296
12297         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12298
12299         has_beep = 0;
12300         for (i = 0; i < spec->num_mixers; i++) {
12301                 if (spec->mixers[i] == alc268_beep_mixer) {
12302                         has_beep = 1;
12303                         break;
12304                 }
12305         }
12306
12307         if (has_beep) {
12308                 err = snd_hda_attach_beep_device(codec, 0x1);
12309                 if (err < 0) {
12310                         alc_free(codec);
12311                         return err;
12312                 }
12313                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12314                         /* override the amp caps for beep generator */
12315                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12316                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12317                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12318                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12319                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12320         }
12321
12322         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12323                 /* check whether NID 0x07 is valid */
12324                 unsigned int wcap = get_wcaps(codec, 0x07);
12325                 int i;
12326
12327                 /* get type */
12328                 wcap = (wcap & AC_WCAP_TYPE) >> AC_WCAP_TYPE_SHIFT;
12329                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12330                         spec->adc_nids = alc268_adc_nids_alt;
12331                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12332                         add_mixer(spec, alc268_capture_alt_mixer);
12333                 } else {
12334                         spec->adc_nids = alc268_adc_nids;
12335                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12336                         add_mixer(spec, alc268_capture_mixer);
12337                 }
12338                 spec->capsrc_nids = alc268_capsrc_nids;
12339                 /* set default input source */
12340                 for (i = 0; i < spec->num_adc_nids; i++)
12341                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12342                                 0, AC_VERB_SET_CONNECT_SEL,
12343                                 spec->input_mux->items[0].index);
12344         }
12345
12346         spec->vmaster_nid = 0x02;
12347
12348         codec->patch_ops = alc_patch_ops;
12349         if (board_config == ALC268_AUTO)
12350                 spec->init_hook = alc268_auto_init;
12351
12352         codec->proc_widget_hook = print_realtek_coef;
12353
12354         return 0;
12355 }
12356
12357 /*
12358  *  ALC269 channel source setting (2 channel)
12359  */
12360 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12361
12362 #define alc269_dac_nids         alc260_dac_nids
12363
12364 static hda_nid_t alc269_adc_nids[1] = {
12365         /* ADC1 */
12366         0x08,
12367 };
12368
12369 static hda_nid_t alc269_capsrc_nids[1] = {
12370         0x23,
12371 };
12372
12373 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12374  *       not a mux!
12375  */
12376
12377 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12378         .num_items = 2,
12379         .items = {
12380                 { "i-Mic", 0x5 },
12381                 { "e-Mic", 0x0 },
12382         },
12383 };
12384
12385 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12386         .num_items = 2,
12387         .items = {
12388                 { "i-Mic", 0x1 },
12389                 { "e-Mic", 0x0 },
12390         },
12391 };
12392
12393 #define alc269_modes            alc260_modes
12394 #define alc269_capture_source   alc880_lg_lw_capture_source
12395
12396 static struct snd_kcontrol_new alc269_base_mixer[] = {
12397         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12398         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12399         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12400         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12401         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12402         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12403         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12404         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12405         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12406         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12407         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12408         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12409         { } /* end */
12410 };
12411
12412 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12413         /* output mixer control */
12414         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12415         {
12416                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12417                 .name = "Master Playback Switch",
12418                 .info = snd_hda_mixer_amp_switch_info,
12419                 .get = snd_hda_mixer_amp_switch_get,
12420                 .put = alc268_acer_master_sw_put,
12421                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12422         },
12423         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12424         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12425         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12426         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12427         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12428         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12429         { }
12430 };
12431
12432 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12433         /* output mixer control */
12434         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12435         {
12436                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12437                 .name = "Master Playback Switch",
12438                 .info = snd_hda_mixer_amp_switch_info,
12439                 .get = snd_hda_mixer_amp_switch_get,
12440                 .put = alc268_acer_master_sw_put,
12441                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12442         },
12443         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12444         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12445         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12446         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12447         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12448         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12449         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12450         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12451         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12452         { }
12453 };
12454
12455 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12456         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12457         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12458         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12459         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12460         { } /* end */
12461 };
12462
12463 /* capture mixer elements */
12464 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12465         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12466         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12467         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12468         { } /* end */
12469 };
12470
12471 /* FSC amilo */
12472 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
12473
12474 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12475         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12476         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12477         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12478         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12479         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12480         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12481         { }
12482 };
12483
12484 static struct hda_verb alc269_lifebook_verbs[] = {
12485         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12486         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12487         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12488         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12489         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12490         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12491         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12492         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12493         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12494         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12495         { }
12496 };
12497
12498 /* toggle speaker-output according to the hp-jack state */
12499 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12500 {
12501         unsigned int present;
12502         unsigned char bits;
12503
12504         present = snd_hda_codec_read(codec, 0x15, 0,
12505                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12506         bits = present ? AMP_IN_MUTE(0) : 0;
12507         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12508                         AMP_IN_MUTE(0), bits);
12509         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12510                         AMP_IN_MUTE(0), bits);
12511
12512         snd_hda_codec_write(codec, 0x20, 0,
12513                         AC_VERB_SET_COEF_INDEX, 0x0c);
12514         snd_hda_codec_write(codec, 0x20, 0,
12515                         AC_VERB_SET_PROC_COEF, 0x680);
12516
12517         snd_hda_codec_write(codec, 0x20, 0,
12518                         AC_VERB_SET_COEF_INDEX, 0x0c);
12519         snd_hda_codec_write(codec, 0x20, 0,
12520                         AC_VERB_SET_PROC_COEF, 0x480);
12521 }
12522
12523 /* toggle speaker-output according to the hp-jacks state */
12524 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12525 {
12526         unsigned int present;
12527         unsigned char bits;
12528
12529         /* Check laptop headphone socket */
12530         present = snd_hda_codec_read(codec, 0x15, 0,
12531                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12532
12533         /* Check port replicator headphone socket */
12534         present |= snd_hda_codec_read(codec, 0x1a, 0,
12535                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12536
12537         bits = present ? AMP_IN_MUTE(0) : 0;
12538         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12539                         AMP_IN_MUTE(0), bits);
12540         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12541                         AMP_IN_MUTE(0), bits);
12542
12543         snd_hda_codec_write(codec, 0x20, 0,
12544                         AC_VERB_SET_COEF_INDEX, 0x0c);
12545         snd_hda_codec_write(codec, 0x20, 0,
12546                         AC_VERB_SET_PROC_COEF, 0x680);
12547
12548         snd_hda_codec_write(codec, 0x20, 0,
12549                         AC_VERB_SET_COEF_INDEX, 0x0c);
12550         snd_hda_codec_write(codec, 0x20, 0,
12551                         AC_VERB_SET_PROC_COEF, 0x480);
12552 }
12553
12554 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12555 {
12556         unsigned int present;
12557
12558         present = snd_hda_codec_read(codec, 0x18, 0,
12559                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12560         snd_hda_codec_write(codec, 0x23, 0,
12561                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12562 }
12563
12564 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12565 {
12566         unsigned int present_laptop;
12567         unsigned int present_dock;
12568
12569         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12570                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12571
12572         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12573                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12574
12575         /* Laptop mic port overrides dock mic port, design decision */
12576         if (present_dock)
12577                 snd_hda_codec_write(codec, 0x23, 0,
12578                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12579         if (present_laptop)
12580                 snd_hda_codec_write(codec, 0x23, 0,
12581                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12582         if (!present_dock && !present_laptop)
12583                 snd_hda_codec_write(codec, 0x23, 0,
12584                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12585 }
12586
12587 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12588                                     unsigned int res)
12589 {
12590         if ((res >> 26) == ALC880_HP_EVENT)
12591                 alc269_quanta_fl1_speaker_automute(codec);
12592         if ((res >> 26) == ALC880_MIC_EVENT)
12593                 alc269_quanta_fl1_mic_automute(codec);
12594 }
12595
12596 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12597                                         unsigned int res)
12598 {
12599         if ((res >> 26) == ALC880_HP_EVENT)
12600                 alc269_lifebook_speaker_automute(codec);
12601         if ((res >> 26) == ALC880_MIC_EVENT)
12602                 alc269_lifebook_mic_autoswitch(codec);
12603 }
12604
12605 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12606 {
12607         alc269_quanta_fl1_speaker_automute(codec);
12608         alc269_quanta_fl1_mic_automute(codec);
12609 }
12610
12611 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12612 {
12613         alc269_lifebook_speaker_automute(codec);
12614         alc269_lifebook_mic_autoswitch(codec);
12615 }
12616
12617 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12618         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12619         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12620         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12621         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12622         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12623         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12624         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12625         {}
12626 };
12627
12628 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12629         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12630         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12631         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12632         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12633         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12634         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12635         {}
12636 };
12637
12638 /* toggle speaker-output according to the hp-jack state */
12639 static void alc269_speaker_automute(struct hda_codec *codec)
12640 {
12641         unsigned int present;
12642         unsigned char bits;
12643
12644         present = snd_hda_codec_read(codec, 0x15, 0,
12645                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12646         bits = present ? AMP_IN_MUTE(0) : 0;
12647         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12648                                 AMP_IN_MUTE(0), bits);
12649         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12650                                 AMP_IN_MUTE(0), bits);
12651 }
12652
12653 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
12654 {
12655         unsigned int present;
12656
12657         present = snd_hda_codec_read(codec, 0x18, 0,
12658                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12659         snd_hda_codec_write(codec, 0x23, 0,
12660                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
12661 }
12662
12663 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
12664 {
12665         unsigned int present;
12666
12667         present = snd_hda_codec_read(codec, 0x18, 0,
12668                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12669         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12670                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
12671         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
12672                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
12673 }
12674
12675 /* unsolicited event for HP jack sensing */
12676 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
12677                                      unsigned int res)
12678 {
12679         if ((res >> 26) == ALC880_HP_EVENT)
12680                 alc269_speaker_automute(codec);
12681
12682         if ((res >> 26) == ALC880_MIC_EVENT)
12683                 alc269_eeepc_dmic_automute(codec);
12684 }
12685
12686 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
12687 {
12688         alc269_speaker_automute(codec);
12689         alc269_eeepc_dmic_automute(codec);
12690 }
12691
12692 /* unsolicited event for HP jack sensing */
12693 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
12694                                      unsigned int res)
12695 {
12696         if ((res >> 26) == ALC880_HP_EVENT)
12697                 alc269_speaker_automute(codec);
12698
12699         if ((res >> 26) == ALC880_MIC_EVENT)
12700                 alc269_eeepc_amic_automute(codec);
12701 }
12702
12703 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
12704 {
12705         alc269_speaker_automute(codec);
12706         alc269_eeepc_amic_automute(codec);
12707 }
12708
12709 /*
12710  * generic initialization of ADC, input mixers and output mixers
12711  */
12712 static struct hda_verb alc269_init_verbs[] = {
12713         /*
12714          * Unmute ADC0 and set the default input to mic-in
12715          */
12716         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12717
12718         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
12719          * analog-loopback mixer widget
12720          * Note: PASD motherboards uses the Line In 2 as the input for
12721          * front panel mic (mic 2)
12722          */
12723         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12724         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12725         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12726         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12727         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12728         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12729
12730         /*
12731          * Set up output mixers (0x0c - 0x0e)
12732          */
12733         /* set vol=0 to output mixers */
12734         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12735         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12736
12737         /* set up input amps for analog loopback */
12738         /* Amp Indices: DAC = 0, mixer = 1 */
12739         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12740         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12741         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12742         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12743         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12744         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12745
12746         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12747         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12748         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12749         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12750         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12751         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12752         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12753
12754         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12755         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12756         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12757         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12758         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12759         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12760         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12761
12762         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
12763         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12764
12765         /* FIXME: use matrix-type input source selection */
12766         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
12767         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12768         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12769         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12770         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12771         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12772
12773         /* set EAPD */
12774         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12775         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12776         { }
12777 };
12778
12779 /* add playback controls from the parsed DAC table */
12780 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
12781                                              const struct auto_pin_cfg *cfg)
12782 {
12783         hda_nid_t nid;
12784         int err;
12785
12786         spec->multiout.num_dacs = 1;    /* only use one dac */
12787         spec->multiout.dac_nids = spec->private_dac_nids;
12788         spec->multiout.dac_nids[0] = 2;
12789
12790         nid = cfg->line_out_pins[0];
12791         if (nid) {
12792                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12793                                   "Front Playback Volume",
12794                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
12795                 if (err < 0)
12796                         return err;
12797                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12798                                   "Front Playback Switch",
12799                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
12800                 if (err < 0)
12801                         return err;
12802         }
12803
12804         nid = cfg->speaker_pins[0];
12805         if (nid) {
12806                 if (!cfg->line_out_pins[0]) {
12807                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12808                                           "Speaker Playback Volume",
12809                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12810                                                               HDA_OUTPUT));
12811                         if (err < 0)
12812                                 return err;
12813                 }
12814                 if (nid == 0x16) {
12815                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12816                                           "Speaker Playback Switch",
12817                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12818                                                               HDA_OUTPUT));
12819                         if (err < 0)
12820                                 return err;
12821                 } else {
12822                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12823                                           "Speaker Playback Switch",
12824                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12825                                                               HDA_OUTPUT));
12826                         if (err < 0)
12827                                 return err;
12828                 }
12829         }
12830         nid = cfg->hp_pins[0];
12831         if (nid) {
12832                 /* spec->multiout.hp_nid = 2; */
12833                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
12834                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
12835                                           "Headphone Playback Volume",
12836                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
12837                                                               HDA_OUTPUT));
12838                         if (err < 0)
12839                                 return err;
12840                 }
12841                 if (nid == 0x16) {
12842                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12843                                           "Headphone Playback Switch",
12844                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
12845                                                               HDA_OUTPUT));
12846                         if (err < 0)
12847                                 return err;
12848                 } else {
12849                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12850                                           "Headphone Playback Switch",
12851                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
12852                                                               HDA_OUTPUT));
12853                         if (err < 0)
12854                                 return err;
12855                 }
12856         }
12857         return 0;
12858 }
12859
12860 #define alc269_auto_create_analog_input_ctls \
12861         alc262_auto_create_analog_input_ctls
12862
12863 #ifdef CONFIG_SND_HDA_POWER_SAVE
12864 #define alc269_loopbacks        alc880_loopbacks
12865 #endif
12866
12867 /* pcm configuration: identical with ALC880 */
12868 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
12869 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
12870 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
12871 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
12872
12873 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
12874         .substreams = 1,
12875         .channels_min = 2,
12876         .channels_max = 8,
12877         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12878         /* NID is set in alc_build_pcms */
12879         .ops = {
12880                 .open = alc880_playback_pcm_open,
12881                 .prepare = alc880_playback_pcm_prepare,
12882                 .cleanup = alc880_playback_pcm_cleanup
12883         },
12884 };
12885
12886 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
12887         .substreams = 1,
12888         .channels_min = 2,
12889         .channels_max = 2,
12890         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
12891         /* NID is set in alc_build_pcms */
12892 };
12893
12894 /*
12895  * BIOS auto configuration
12896  */
12897 static int alc269_parse_auto_config(struct hda_codec *codec)
12898 {
12899         struct alc_spec *spec = codec->spec;
12900         int err;
12901         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
12902
12903         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12904                                            alc269_ignore);
12905         if (err < 0)
12906                 return err;
12907
12908         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
12909         if (err < 0)
12910                 return err;
12911         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
12912         if (err < 0)
12913                 return err;
12914
12915         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12916
12917         if (spec->autocfg.dig_outs)
12918                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
12919
12920         if (spec->kctls.list)
12921                 add_mixer(spec, spec->kctls.list);
12922
12923         add_verb(spec, alc269_init_verbs);
12924         spec->num_mux_defs = 1;
12925         spec->input_mux = &spec->private_imux[0];
12926         /* set default input source */
12927         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
12928                                   0, AC_VERB_SET_CONNECT_SEL,
12929                                   spec->input_mux->items[0].index);
12930
12931         err = alc_auto_add_mic_boost(codec);
12932         if (err < 0)
12933                 return err;
12934
12935         if (!spec->cap_mixer && !spec->no_analog)
12936                 set_capture_mixer(spec);
12937
12938         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12939
12940         return 1;
12941 }
12942
12943 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
12944 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
12945 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
12946
12947
12948 /* init callback for auto-configuration model -- overriding the default init */
12949 static void alc269_auto_init(struct hda_codec *codec)
12950 {
12951         struct alc_spec *spec = codec->spec;
12952         alc269_auto_init_multi_out(codec);
12953         alc269_auto_init_hp_out(codec);
12954         alc269_auto_init_analog_input(codec);
12955         if (spec->unsol_event)
12956                 alc_inithook(codec);
12957 }
12958
12959 /*
12960  * configuration and preset
12961  */
12962 static const char *alc269_models[ALC269_MODEL_LAST] = {
12963         [ALC269_BASIC]                  = "basic",
12964         [ALC269_QUANTA_FL1]             = "quanta",
12965         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
12966         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
12967         [ALC269_FUJITSU]                = "fujitsu",
12968         [ALC269_LIFEBOOK]               = "lifebook"
12969 };
12970
12971 static struct snd_pci_quirk alc269_cfg_tbl[] = {
12972         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
12973         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
12974                       ALC269_ASUS_EEEPC_P703),
12975         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
12976         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
12977         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
12978         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
12979         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
12980         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
12981         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
12982                       ALC269_ASUS_EEEPC_P901),
12983         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
12984                       ALC269_ASUS_EEEPC_P901),
12985         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
12986         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
12987         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
12988         {}
12989 };
12990
12991 static struct alc_config_preset alc269_presets[] = {
12992         [ALC269_BASIC] = {
12993                 .mixers = { alc269_base_mixer },
12994                 .init_verbs = { alc269_init_verbs },
12995                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
12996                 .dac_nids = alc269_dac_nids,
12997                 .hp_nid = 0x03,
12998                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
12999                 .channel_mode = alc269_modes,
13000                 .input_mux = &alc269_capture_source,
13001         },
13002         [ALC269_QUANTA_FL1] = {
13003                 .mixers = { alc269_quanta_fl1_mixer },
13004                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13005                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13006                 .dac_nids = alc269_dac_nids,
13007                 .hp_nid = 0x03,
13008                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13009                 .channel_mode = alc269_modes,
13010                 .input_mux = &alc269_capture_source,
13011                 .unsol_event = alc269_quanta_fl1_unsol_event,
13012                 .init_hook = alc269_quanta_fl1_init_hook,
13013         },
13014         [ALC269_ASUS_EEEPC_P703] = {
13015                 .mixers = { alc269_eeepc_mixer },
13016                 .cap_mixer = alc269_epc_capture_mixer,
13017                 .init_verbs = { alc269_init_verbs,
13018                                 alc269_eeepc_amic_init_verbs },
13019                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13020                 .dac_nids = alc269_dac_nids,
13021                 .hp_nid = 0x03,
13022                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13023                 .channel_mode = alc269_modes,
13024                 .input_mux = &alc269_eeepc_amic_capture_source,
13025                 .unsol_event = alc269_eeepc_amic_unsol_event,
13026                 .init_hook = alc269_eeepc_amic_inithook,
13027         },
13028         [ALC269_ASUS_EEEPC_P901] = {
13029                 .mixers = { alc269_eeepc_mixer },
13030                 .cap_mixer = alc269_epc_capture_mixer,
13031                 .init_verbs = { alc269_init_verbs,
13032                                 alc269_eeepc_dmic_init_verbs },
13033                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13034                 .dac_nids = alc269_dac_nids,
13035                 .hp_nid = 0x03,
13036                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13037                 .channel_mode = alc269_modes,
13038                 .input_mux = &alc269_eeepc_dmic_capture_source,
13039                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13040                 .init_hook = alc269_eeepc_dmic_inithook,
13041         },
13042         [ALC269_FUJITSU] = {
13043                 .mixers = { alc269_fujitsu_mixer },
13044                 .cap_mixer = alc269_epc_capture_mixer,
13045                 .init_verbs = { alc269_init_verbs,
13046                                 alc269_eeepc_dmic_init_verbs },
13047                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13048                 .dac_nids = alc269_dac_nids,
13049                 .hp_nid = 0x03,
13050                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13051                 .channel_mode = alc269_modes,
13052                 .input_mux = &alc269_eeepc_dmic_capture_source,
13053                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13054                 .init_hook = alc269_eeepc_dmic_inithook,
13055         },
13056         [ALC269_LIFEBOOK] = {
13057                 .mixers = { alc269_lifebook_mixer },
13058                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13059                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13060                 .dac_nids = alc269_dac_nids,
13061                 .hp_nid = 0x03,
13062                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13063                 .channel_mode = alc269_modes,
13064                 .input_mux = &alc269_capture_source,
13065                 .unsol_event = alc269_lifebook_unsol_event,
13066                 .init_hook = alc269_lifebook_init_hook,
13067         },
13068 };
13069
13070 static int patch_alc269(struct hda_codec *codec)
13071 {
13072         struct alc_spec *spec;
13073         int board_config;
13074         int err;
13075
13076         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13077         if (spec == NULL)
13078                 return -ENOMEM;
13079
13080         codec->spec = spec;
13081
13082         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13083
13084         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13085                                                   alc269_models,
13086                                                   alc269_cfg_tbl);
13087
13088         if (board_config < 0) {
13089                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
13090                        "trying auto-probe from BIOS...\n", codec->chip_name);
13091                 board_config = ALC269_AUTO;
13092         }
13093
13094         if (board_config == ALC269_AUTO) {
13095                 /* automatic parse from the BIOS config */
13096                 err = alc269_parse_auto_config(codec);
13097                 if (err < 0) {
13098                         alc_free(codec);
13099                         return err;
13100                 } else if (!err) {
13101                         printk(KERN_INFO
13102                                "hda_codec: Cannot set up configuration "
13103                                "from BIOS.  Using base mode...\n");
13104                         board_config = ALC269_BASIC;
13105                 }
13106         }
13107
13108         err = snd_hda_attach_beep_device(codec, 0x1);
13109         if (err < 0) {
13110                 alc_free(codec);
13111                 return err;
13112         }
13113
13114         if (board_config != ALC269_AUTO)
13115                 setup_preset(spec, &alc269_presets[board_config]);
13116
13117         if (codec->subsystem_id == 0x17aa3bf8) {
13118                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13119                  * fix the sample rate of analog I/O to 44.1kHz
13120                  */
13121                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13122                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13123         } else {
13124                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13125                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13126         }
13127         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13128         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13129
13130         spec->adc_nids = alc269_adc_nids;
13131         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13132         spec->capsrc_nids = alc269_capsrc_nids;
13133         if (!spec->cap_mixer)
13134                 set_capture_mixer(spec);
13135         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13136
13137         codec->patch_ops = alc_patch_ops;
13138         if (board_config == ALC269_AUTO)
13139                 spec->init_hook = alc269_auto_init;
13140 #ifdef CONFIG_SND_HDA_POWER_SAVE
13141         if (!spec->loopback.amplist)
13142                 spec->loopback.amplist = alc269_loopbacks;
13143 #endif
13144         codec->proc_widget_hook = print_realtek_coef;
13145
13146         return 0;
13147 }
13148
13149 /*
13150  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13151  */
13152
13153 /*
13154  * set the path ways for 2 channel output
13155  * need to set the codec line out and mic 1 pin widgets to inputs
13156  */
13157 static struct hda_verb alc861_threestack_ch2_init[] = {
13158         /* set pin widget 1Ah (line in) for input */
13159         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13160         /* set pin widget 18h (mic1/2) for input, for mic also enable
13161          * the vref
13162          */
13163         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13164
13165         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13166 #if 0
13167         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13168         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13169 #endif
13170         { } /* end */
13171 };
13172 /*
13173  * 6ch mode
13174  * need to set the codec line out and mic 1 pin widgets to outputs
13175  */
13176 static struct hda_verb alc861_threestack_ch6_init[] = {
13177         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13178         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13179         /* set pin widget 18h (mic1) for output (CLFE)*/
13180         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13181
13182         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13183         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13184
13185         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13186 #if 0
13187         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13188         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13189 #endif
13190         { } /* end */
13191 };
13192
13193 static struct hda_channel_mode alc861_threestack_modes[2] = {
13194         { 2, alc861_threestack_ch2_init },
13195         { 6, alc861_threestack_ch6_init },
13196 };
13197 /* Set mic1 as input and unmute the mixer */
13198 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13199         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13200         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13201         { } /* end */
13202 };
13203 /* Set mic1 as output and mute mixer */
13204 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13205         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13206         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13207         { } /* end */
13208 };
13209
13210 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13211         { 2, alc861_uniwill_m31_ch2_init },
13212         { 4, alc861_uniwill_m31_ch4_init },
13213 };
13214
13215 /* Set mic1 and line-in as input and unmute the mixer */
13216 static struct hda_verb alc861_asus_ch2_init[] = {
13217         /* set pin widget 1Ah (line in) for input */
13218         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13219         /* set pin widget 18h (mic1/2) for input, for mic also enable
13220          * the vref
13221          */
13222         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13223
13224         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13225 #if 0
13226         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13227         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13228 #endif
13229         { } /* end */
13230 };
13231 /* Set mic1 nad line-in as output and mute mixer */
13232 static struct hda_verb alc861_asus_ch6_init[] = {
13233         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13234         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13235         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13236         /* set pin widget 18h (mic1) for output (CLFE)*/
13237         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13238         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13239         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13240         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13241
13242         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13243 #if 0
13244         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13245         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13246 #endif
13247         { } /* end */
13248 };
13249
13250 static struct hda_channel_mode alc861_asus_modes[2] = {
13251         { 2, alc861_asus_ch2_init },
13252         { 6, alc861_asus_ch6_init },
13253 };
13254
13255 /* patch-ALC861 */
13256
13257 static struct snd_kcontrol_new alc861_base_mixer[] = {
13258         /* output mixer control */
13259         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13260         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13261         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13262         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13263         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13264
13265         /*Input mixer control */
13266         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13267            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13268         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13269         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13270         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13271         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13273         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13274         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13275         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13276
13277         { } /* end */
13278 };
13279
13280 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13281         /* output mixer control */
13282         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13283         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13284         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13285         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13286         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13287
13288         /* Input mixer control */
13289         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13290            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13291         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13292         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13293         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13294         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13295         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13296         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13297         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13298         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13299
13300         {
13301                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13302                 .name = "Channel Mode",
13303                 .info = alc_ch_mode_info,
13304                 .get = alc_ch_mode_get,
13305                 .put = alc_ch_mode_put,
13306                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13307         },
13308         { } /* end */
13309 };
13310
13311 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13312         /* output mixer control */
13313         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13314         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13315         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13316
13317         { } /* end */
13318 };
13319
13320 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13321         /* output mixer control */
13322         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13323         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13324         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13325         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13326         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13327
13328         /* Input mixer control */
13329         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13330            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13331         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13332         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13333         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13334         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13335         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13336         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13337         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13338         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13339
13340         {
13341                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13342                 .name = "Channel Mode",
13343                 .info = alc_ch_mode_info,
13344                 .get = alc_ch_mode_get,
13345                 .put = alc_ch_mode_put,
13346                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13347         },
13348         { } /* end */
13349 };
13350
13351 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13352         /* output mixer control */
13353         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13354         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13355         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13356         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13357         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13358
13359         /* Input mixer control */
13360         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13361         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13362         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13363         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13364         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13365         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13366         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13367         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13368         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13369         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13370
13371         {
13372                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13373                 .name = "Channel Mode",
13374                 .info = alc_ch_mode_info,
13375                 .get = alc_ch_mode_get,
13376                 .put = alc_ch_mode_put,
13377                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13378         },
13379         { }
13380 };
13381
13382 /* additional mixer */
13383 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13384         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13385         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13386         { }
13387 };
13388
13389 /*
13390  * generic initialization of ADC, input mixers and output mixers
13391  */
13392 static struct hda_verb alc861_base_init_verbs[] = {
13393         /*
13394          * Unmute ADC0 and set the default input to mic-in
13395          */
13396         /* port-A for surround (rear panel) */
13397         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13398         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13399         /* port-B for mic-in (rear panel) with vref */
13400         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13401         /* port-C for line-in (rear panel) */
13402         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13403         /* port-D for Front */
13404         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13405         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13406         /* port-E for HP out (front panel) */
13407         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13408         /* route front PCM to HP */
13409         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13410         /* port-F for mic-in (front panel) with vref */
13411         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13412         /* port-G for CLFE (rear panel) */
13413         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13414         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13415         /* port-H for side (rear panel) */
13416         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13417         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13418         /* CD-in */
13419         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13420         /* route front mic to ADC1*/
13421         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13422         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13423
13424         /* Unmute DAC0~3 & spdif out*/
13425         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13426         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13427         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13428         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13429         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13430
13431         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13432         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13433         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13434         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13435         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13436
13437         /* Unmute Stereo Mixer 15 */
13438         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13439         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13440         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13441         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13442
13443         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13444         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13445         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13446         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13447         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13448         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13449         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13450         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13451         /* hp used DAC 3 (Front) */
13452         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13453         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13454
13455         { }
13456 };
13457
13458 static struct hda_verb alc861_threestack_init_verbs[] = {
13459         /*
13460          * Unmute ADC0 and set the default input to mic-in
13461          */
13462         /* port-A for surround (rear panel) */
13463         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13464         /* port-B for mic-in (rear panel) with vref */
13465         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13466         /* port-C for line-in (rear panel) */
13467         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13468         /* port-D for Front */
13469         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13470         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13471         /* port-E for HP out (front panel) */
13472         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13473         /* route front PCM to HP */
13474         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13475         /* port-F for mic-in (front panel) with vref */
13476         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13477         /* port-G for CLFE (rear panel) */
13478         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13479         /* port-H for side (rear panel) */
13480         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13481         /* CD-in */
13482         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13483         /* route front mic to ADC1*/
13484         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13485         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13486         /* Unmute DAC0~3 & spdif out*/
13487         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13488         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13489         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13490         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13491         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13492
13493         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13494         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13495         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13496         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13497         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13498
13499         /* Unmute Stereo Mixer 15 */
13500         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13501         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13502         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13503         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13504
13505         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13506         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13507         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13508         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13509         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13510         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13511         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13512         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13513         /* hp used DAC 3 (Front) */
13514         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13515         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13516         { }
13517 };
13518
13519 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13520         /*
13521          * Unmute ADC0 and set the default input to mic-in
13522          */
13523         /* port-A for surround (rear panel) */
13524         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13525         /* port-B for mic-in (rear panel) with vref */
13526         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13527         /* port-C for line-in (rear panel) */
13528         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13529         /* port-D for Front */
13530         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13531         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13532         /* port-E for HP out (front panel) */
13533         /* this has to be set to VREF80 */
13534         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13535         /* route front PCM to HP */
13536         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13537         /* port-F for mic-in (front panel) with vref */
13538         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13539         /* port-G for CLFE (rear panel) */
13540         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13541         /* port-H for side (rear panel) */
13542         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13543         /* CD-in */
13544         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13545         /* route front mic to ADC1*/
13546         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13547         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13548         /* Unmute DAC0~3 & spdif out*/
13549         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13550         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13551         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13552         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13554
13555         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13556         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13557         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13558         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13559         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13560
13561         /* Unmute Stereo Mixer 15 */
13562         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13563         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13564         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13565         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13566
13567         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13568         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13569         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13570         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13571         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13572         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13573         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13574         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13575         /* hp used DAC 3 (Front) */
13576         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13577         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13578         { }
13579 };
13580
13581 static struct hda_verb alc861_asus_init_verbs[] = {
13582         /*
13583          * Unmute ADC0 and set the default input to mic-in
13584          */
13585         /* port-A for surround (rear panel)
13586          * according to codec#0 this is the HP jack
13587          */
13588         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13589         /* route front PCM to HP */
13590         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13591         /* port-B for mic-in (rear panel) with vref */
13592         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13593         /* port-C for line-in (rear panel) */
13594         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13595         /* port-D for Front */
13596         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13597         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13598         /* port-E for HP out (front panel) */
13599         /* this has to be set to VREF80 */
13600         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13601         /* route front PCM to HP */
13602         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13603         /* port-F for mic-in (front panel) with vref */
13604         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13605         /* port-G for CLFE (rear panel) */
13606         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13607         /* port-H for side (rear panel) */
13608         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13609         /* CD-in */
13610         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13611         /* route front mic to ADC1*/
13612         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13613         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13614         /* Unmute DAC0~3 & spdif out*/
13615         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13616         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13617         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13618         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13619         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13620         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13621         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13622         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13623         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13624         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13625
13626         /* Unmute Stereo Mixer 15 */
13627         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13628         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13629         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13630         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13631
13632         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13633         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13634         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13635         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13636         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13637         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13639         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13640         /* hp used DAC 3 (Front) */
13641         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13642         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13643         { }
13644 };
13645
13646 /* additional init verbs for ASUS laptops */
13647 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
13648         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
13649         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
13650         { }
13651 };
13652
13653 /*
13654  * generic initialization of ADC, input mixers and output mixers
13655  */
13656 static struct hda_verb alc861_auto_init_verbs[] = {
13657         /*
13658          * Unmute ADC0 and set the default input to mic-in
13659          */
13660         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
13661         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13662
13663         /* Unmute DAC0~3 & spdif out*/
13664         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13665         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13666         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13667         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13668         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13669
13670         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13671         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13672         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13673         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13674         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13675
13676         /* Unmute Stereo Mixer 15 */
13677         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13678         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13679         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13680         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
13681
13682         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13683         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13684         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13685         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13686         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13687         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13688         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13689         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13690
13691         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13692         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13693         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13694         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13695         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13696         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13697         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13698         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13699
13700         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
13701
13702         { }
13703 };
13704
13705 static struct hda_verb alc861_toshiba_init_verbs[] = {
13706         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13707
13708         { }
13709 };
13710
13711 /* toggle speaker-output according to the hp-jack state */
13712 static void alc861_toshiba_automute(struct hda_codec *codec)
13713 {
13714         unsigned int present;
13715
13716         present = snd_hda_codec_read(codec, 0x0f, 0,
13717                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13718         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
13719                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
13720         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
13721                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
13722 }
13723
13724 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
13725                                        unsigned int res)
13726 {
13727         if ((res >> 26) == ALC880_HP_EVENT)
13728                 alc861_toshiba_automute(codec);
13729 }
13730
13731 /* pcm configuration: identical with ALC880 */
13732 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
13733 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
13734 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
13735 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
13736
13737
13738 #define ALC861_DIGOUT_NID       0x07
13739
13740 static struct hda_channel_mode alc861_8ch_modes[1] = {
13741         { 8, NULL }
13742 };
13743
13744 static hda_nid_t alc861_dac_nids[4] = {
13745         /* front, surround, clfe, side */
13746         0x03, 0x06, 0x05, 0x04
13747 };
13748
13749 static hda_nid_t alc660_dac_nids[3] = {
13750         /* front, clfe, surround */
13751         0x03, 0x05, 0x06
13752 };
13753
13754 static hda_nid_t alc861_adc_nids[1] = {
13755         /* ADC0-2 */
13756         0x08,
13757 };
13758
13759 static struct hda_input_mux alc861_capture_source = {
13760         .num_items = 5,
13761         .items = {
13762                 { "Mic", 0x0 },
13763                 { "Front Mic", 0x3 },
13764                 { "Line", 0x1 },
13765                 { "CD", 0x4 },
13766                 { "Mixer", 0x5 },
13767         },
13768 };
13769
13770 /* fill in the dac_nids table from the parsed pin configuration */
13771 static int alc861_auto_fill_dac_nids(struct alc_spec *spec,
13772                                      const struct auto_pin_cfg *cfg)
13773 {
13774         int i;
13775         hda_nid_t nid;
13776
13777         spec->multiout.dac_nids = spec->private_dac_nids;
13778         for (i = 0; i < cfg->line_outs; i++) {
13779                 nid = cfg->line_out_pins[i];
13780                 if (nid) {
13781                         if (i >= ARRAY_SIZE(alc861_dac_nids))
13782                                 continue;
13783                         spec->multiout.dac_nids[i] = alc861_dac_nids[i];
13784                 }
13785         }
13786         spec->multiout.num_dacs = cfg->line_outs;
13787         return 0;
13788 }
13789
13790 /* add playback controls from the parsed DAC table */
13791 static int alc861_auto_create_multi_out_ctls(struct alc_spec *spec,
13792                                              const struct auto_pin_cfg *cfg)
13793 {
13794         char name[32];
13795         static const char *chname[4] = {
13796                 "Front", "Surround", NULL /*CLFE*/, "Side"
13797         };
13798         hda_nid_t nid;
13799         int i, idx, err;
13800
13801         for (i = 0; i < cfg->line_outs; i++) {
13802                 nid = spec->multiout.dac_nids[i];
13803                 if (!nid)
13804                         continue;
13805                 if (nid == 0x05) {
13806                         /* Center/LFE */
13807                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13808                                           "Center Playback Switch",
13809                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
13810                                                               HDA_OUTPUT));
13811                         if (err < 0)
13812                                 return err;
13813                         err = add_control(spec, ALC_CTL_BIND_MUTE,
13814                                           "LFE Playback Switch",
13815                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13816                                                               HDA_OUTPUT));
13817                         if (err < 0)
13818                                 return err;
13819                 } else {
13820                         for (idx = 0; idx < ARRAY_SIZE(alc861_dac_nids) - 1;
13821                              idx++)
13822                                 if (nid == alc861_dac_nids[idx])
13823                                         break;
13824                         sprintf(name, "%s Playback Switch", chname[idx]);
13825                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
13826                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13827                                                               HDA_OUTPUT));
13828                         if (err < 0)
13829                                 return err;
13830                 }
13831         }
13832         return 0;
13833 }
13834
13835 static int alc861_auto_create_hp_ctls(struct alc_spec *spec, hda_nid_t pin)
13836 {
13837         int err;
13838         hda_nid_t nid;
13839
13840         if (!pin)
13841                 return 0;
13842
13843         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
13844                 nid = 0x03;
13845                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13846                                   "Headphone Playback Switch",
13847                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13848                 if (err < 0)
13849                         return err;
13850                 spec->multiout.hp_nid = nid;
13851         }
13852         return 0;
13853 }
13854
13855 /* create playback/capture controls for input pins */
13856 static int alc861_auto_create_analog_input_ctls(struct alc_spec *spec,
13857                                                 const struct auto_pin_cfg *cfg)
13858 {
13859         struct hda_input_mux *imux = &spec->private_imux[0];
13860         int i, err, idx, idx1;
13861
13862         for (i = 0; i < AUTO_PIN_LAST; i++) {
13863                 switch (cfg->input_pins[i]) {
13864                 case 0x0c:
13865                         idx1 = 1;
13866                         idx = 2;        /* Line In */
13867                         break;
13868                 case 0x0f:
13869                         idx1 = 2;
13870                         idx = 2;        /* Line In */
13871                         break;
13872                 case 0x0d:
13873                         idx1 = 0;
13874                         idx = 1;        /* Mic In */
13875                         break;
13876                 case 0x10:
13877                         idx1 = 3;
13878                         idx = 1;        /* Mic In */
13879                         break;
13880                 case 0x11:
13881                         idx1 = 4;
13882                         idx = 0;        /* CD */
13883                         break;
13884                 default:
13885                         continue;
13886                 }
13887
13888                 err = new_analog_input(spec, cfg->input_pins[i],
13889                                        auto_pin_cfg_labels[i], idx, 0x15);
13890                 if (err < 0)
13891                         return err;
13892
13893                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
13894                 imux->items[imux->num_items].index = idx1;
13895                 imux->num_items++;
13896         }
13897         return 0;
13898 }
13899
13900 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
13901                                               hda_nid_t nid,
13902                                               int pin_type, int dac_idx)
13903 {
13904         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
13905                             pin_type);
13906         snd_hda_codec_write(codec, dac_idx, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13907                             AMP_OUT_UNMUTE);
13908 }
13909
13910 static void alc861_auto_init_multi_out(struct hda_codec *codec)
13911 {
13912         struct alc_spec *spec = codec->spec;
13913         int i;
13914
13915         for (i = 0; i < spec->autocfg.line_outs; i++) {
13916                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
13917                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13918                 if (nid)
13919                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
13920                                                           spec->multiout.dac_nids[i]);
13921         }
13922 }
13923
13924 static void alc861_auto_init_hp_out(struct hda_codec *codec)
13925 {
13926         struct alc_spec *spec = codec->spec;
13927         hda_nid_t pin;
13928
13929         pin = spec->autocfg.hp_pins[0];
13930         if (pin) /* connect to front */
13931                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
13932                                                   spec->multiout.dac_nids[0]);
13933         pin = spec->autocfg.speaker_pins[0];
13934         if (pin)
13935                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
13936 }
13937
13938 static void alc861_auto_init_analog_input(struct hda_codec *codec)
13939 {
13940         struct alc_spec *spec = codec->spec;
13941         int i;
13942
13943         for (i = 0; i < AUTO_PIN_LAST; i++) {
13944                 hda_nid_t nid = spec->autocfg.input_pins[i];
13945                 if (nid >= 0x0c && nid <= 0x11)
13946                         alc_set_input_pin(codec, nid, i);
13947         }
13948 }
13949
13950 /* parse the BIOS configuration and set up the alc_spec */
13951 /* return 1 if successful, 0 if the proper config is not found,
13952  * or a negative error code
13953  */
13954 static int alc861_parse_auto_config(struct hda_codec *codec)
13955 {
13956         struct alc_spec *spec = codec->spec;
13957         int err;
13958         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
13959
13960         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13961                                            alc861_ignore);
13962         if (err < 0)
13963                 return err;
13964         if (!spec->autocfg.line_outs)
13965                 return 0; /* can't find valid BIOS pin config */
13966
13967         err = alc861_auto_fill_dac_nids(spec, &spec->autocfg);
13968         if (err < 0)
13969                 return err;
13970         err = alc861_auto_create_multi_out_ctls(spec, &spec->autocfg);
13971         if (err < 0)
13972                 return err;
13973         err = alc861_auto_create_hp_ctls(spec, spec->autocfg.hp_pins[0]);
13974         if (err < 0)
13975                 return err;
13976         err = alc861_auto_create_analog_input_ctls(spec, &spec->autocfg);
13977         if (err < 0)
13978                 return err;
13979
13980         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13981
13982         if (spec->autocfg.dig_outs)
13983                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
13984
13985         if (spec->kctls.list)
13986                 add_mixer(spec, spec->kctls.list);
13987
13988         add_verb(spec, alc861_auto_init_verbs);
13989
13990         spec->num_mux_defs = 1;
13991         spec->input_mux = &spec->private_imux[0];
13992
13993         spec->adc_nids = alc861_adc_nids;
13994         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
13995         set_capture_mixer(spec);
13996
13997         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
13998
13999         return 1;
14000 }
14001
14002 /* additional initialization for auto-configuration model */
14003 static void alc861_auto_init(struct hda_codec *codec)
14004 {
14005         struct alc_spec *spec = codec->spec;
14006         alc861_auto_init_multi_out(codec);
14007         alc861_auto_init_hp_out(codec);
14008         alc861_auto_init_analog_input(codec);
14009         if (spec->unsol_event)
14010                 alc_inithook(codec);
14011 }
14012
14013 #ifdef CONFIG_SND_HDA_POWER_SAVE
14014 static struct hda_amp_list alc861_loopbacks[] = {
14015         { 0x15, HDA_INPUT, 0 },
14016         { 0x15, HDA_INPUT, 1 },
14017         { 0x15, HDA_INPUT, 2 },
14018         { 0x15, HDA_INPUT, 3 },
14019         { } /* end */
14020 };
14021 #endif
14022
14023
14024 /*
14025  * configuration and preset
14026  */
14027 static const char *alc861_models[ALC861_MODEL_LAST] = {
14028         [ALC861_3ST]            = "3stack",
14029         [ALC660_3ST]            = "3stack-660",
14030         [ALC861_3ST_DIG]        = "3stack-dig",
14031         [ALC861_6ST_DIG]        = "6stack-dig",
14032         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14033         [ALC861_TOSHIBA]        = "toshiba",
14034         [ALC861_ASUS]           = "asus",
14035         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14036         [ALC861_AUTO]           = "auto",
14037 };
14038
14039 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14040         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14041         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14042         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14043         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14044         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14045         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14046         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14047         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14048          *        Any other models that need this preset?
14049          */
14050         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14051         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14052         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14053         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14054         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14055         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14056         /* FIXME: the below seems conflict */
14057         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14058         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14059         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14060         {}
14061 };
14062
14063 static struct alc_config_preset alc861_presets[] = {
14064         [ALC861_3ST] = {
14065                 .mixers = { alc861_3ST_mixer },
14066                 .init_verbs = { alc861_threestack_init_verbs },
14067                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14068                 .dac_nids = alc861_dac_nids,
14069                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14070                 .channel_mode = alc861_threestack_modes,
14071                 .need_dac_fix = 1,
14072                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14073                 .adc_nids = alc861_adc_nids,
14074                 .input_mux = &alc861_capture_source,
14075         },
14076         [ALC861_3ST_DIG] = {
14077                 .mixers = { alc861_base_mixer },
14078                 .init_verbs = { alc861_threestack_init_verbs },
14079                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14080                 .dac_nids = alc861_dac_nids,
14081                 .dig_out_nid = ALC861_DIGOUT_NID,
14082                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14083                 .channel_mode = alc861_threestack_modes,
14084                 .need_dac_fix = 1,
14085                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14086                 .adc_nids = alc861_adc_nids,
14087                 .input_mux = &alc861_capture_source,
14088         },
14089         [ALC861_6ST_DIG] = {
14090                 .mixers = { alc861_base_mixer },
14091                 .init_verbs = { alc861_base_init_verbs },
14092                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14093                 .dac_nids = alc861_dac_nids,
14094                 .dig_out_nid = ALC861_DIGOUT_NID,
14095                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14096                 .channel_mode = alc861_8ch_modes,
14097                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14098                 .adc_nids = alc861_adc_nids,
14099                 .input_mux = &alc861_capture_source,
14100         },
14101         [ALC660_3ST] = {
14102                 .mixers = { alc861_3ST_mixer },
14103                 .init_verbs = { alc861_threestack_init_verbs },
14104                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14105                 .dac_nids = alc660_dac_nids,
14106                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14107                 .channel_mode = alc861_threestack_modes,
14108                 .need_dac_fix = 1,
14109                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14110                 .adc_nids = alc861_adc_nids,
14111                 .input_mux = &alc861_capture_source,
14112         },
14113         [ALC861_UNIWILL_M31] = {
14114                 .mixers = { alc861_uniwill_m31_mixer },
14115                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14116                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14117                 .dac_nids = alc861_dac_nids,
14118                 .dig_out_nid = ALC861_DIGOUT_NID,
14119                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14120                 .channel_mode = alc861_uniwill_m31_modes,
14121                 .need_dac_fix = 1,
14122                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14123                 .adc_nids = alc861_adc_nids,
14124                 .input_mux = &alc861_capture_source,
14125         },
14126         [ALC861_TOSHIBA] = {
14127                 .mixers = { alc861_toshiba_mixer },
14128                 .init_verbs = { alc861_base_init_verbs,
14129                                 alc861_toshiba_init_verbs },
14130                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14131                 .dac_nids = alc861_dac_nids,
14132                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14133                 .channel_mode = alc883_3ST_2ch_modes,
14134                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14135                 .adc_nids = alc861_adc_nids,
14136                 .input_mux = &alc861_capture_source,
14137                 .unsol_event = alc861_toshiba_unsol_event,
14138                 .init_hook = alc861_toshiba_automute,
14139         },
14140         [ALC861_ASUS] = {
14141                 .mixers = { alc861_asus_mixer },
14142                 .init_verbs = { alc861_asus_init_verbs },
14143                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14144                 .dac_nids = alc861_dac_nids,
14145                 .dig_out_nid = ALC861_DIGOUT_NID,
14146                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14147                 .channel_mode = alc861_asus_modes,
14148                 .need_dac_fix = 1,
14149                 .hp_nid = 0x06,
14150                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14151                 .adc_nids = alc861_adc_nids,
14152                 .input_mux = &alc861_capture_source,
14153         },
14154         [ALC861_ASUS_LAPTOP] = {
14155                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14156                 .init_verbs = { alc861_asus_init_verbs,
14157                                 alc861_asus_laptop_init_verbs },
14158                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14159                 .dac_nids = alc861_dac_nids,
14160                 .dig_out_nid = ALC861_DIGOUT_NID,
14161                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14162                 .channel_mode = alc883_3ST_2ch_modes,
14163                 .need_dac_fix = 1,
14164                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14165                 .adc_nids = alc861_adc_nids,
14166                 .input_mux = &alc861_capture_source,
14167         },
14168 };
14169
14170
14171 static int patch_alc861(struct hda_codec *codec)
14172 {
14173         struct alc_spec *spec;
14174         int board_config;
14175         int err;
14176
14177         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14178         if (spec == NULL)
14179                 return -ENOMEM;
14180
14181         codec->spec = spec;
14182
14183         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14184                                                   alc861_models,
14185                                                   alc861_cfg_tbl);
14186
14187         if (board_config < 0) {
14188                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
14189                        "trying auto-probe from BIOS...\n", codec->chip_name);
14190                 board_config = ALC861_AUTO;
14191         }
14192
14193         if (board_config == ALC861_AUTO) {
14194                 /* automatic parse from the BIOS config */
14195                 err = alc861_parse_auto_config(codec);
14196                 if (err < 0) {
14197                         alc_free(codec);
14198                         return err;
14199                 } else if (!err) {
14200                         printk(KERN_INFO
14201                                "hda_codec: Cannot set up configuration "
14202                                "from BIOS.  Using base mode...\n");
14203                    board_config = ALC861_3ST_DIG;
14204                 }
14205         }
14206
14207         err = snd_hda_attach_beep_device(codec, 0x23);
14208         if (err < 0) {
14209                 alc_free(codec);
14210                 return err;
14211         }
14212
14213         if (board_config != ALC861_AUTO)
14214                 setup_preset(spec, &alc861_presets[board_config]);
14215
14216         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14217         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14218
14219         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14220         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14221
14222         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14223
14224         spec->vmaster_nid = 0x03;
14225
14226         codec->patch_ops = alc_patch_ops;
14227         if (board_config == ALC861_AUTO)
14228                 spec->init_hook = alc861_auto_init;
14229 #ifdef CONFIG_SND_HDA_POWER_SAVE
14230         if (!spec->loopback.amplist)
14231                 spec->loopback.amplist = alc861_loopbacks;
14232 #endif
14233         codec->proc_widget_hook = print_realtek_coef;
14234
14235         return 0;
14236 }
14237
14238 /*
14239  * ALC861-VD support
14240  *
14241  * Based on ALC882
14242  *
14243  * In addition, an independent DAC
14244  */
14245 #define ALC861VD_DIGOUT_NID     0x06
14246
14247 static hda_nid_t alc861vd_dac_nids[4] = {
14248         /* front, surr, clfe, side surr */
14249         0x02, 0x03, 0x04, 0x05
14250 };
14251
14252 /* dac_nids for ALC660vd are in a different order - according to
14253  * Realtek's driver.
14254  * This should probably result in a different mixer for 6stack models
14255  * of ALC660vd codecs, but for now there is only 3stack mixer
14256  * - and it is the same as in 861vd.
14257  * adc_nids in ALC660vd are (is) the same as in 861vd
14258  */
14259 static hda_nid_t alc660vd_dac_nids[3] = {
14260         /* front, rear, clfe, rear_surr */
14261         0x02, 0x04, 0x03
14262 };
14263
14264 static hda_nid_t alc861vd_adc_nids[1] = {
14265         /* ADC0 */
14266         0x09,
14267 };
14268
14269 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14270
14271 /* input MUX */
14272 /* FIXME: should be a matrix-type input source selection */
14273 static struct hda_input_mux alc861vd_capture_source = {
14274         .num_items = 4,
14275         .items = {
14276                 { "Mic", 0x0 },
14277                 { "Front Mic", 0x1 },
14278                 { "Line", 0x2 },
14279                 { "CD", 0x4 },
14280         },
14281 };
14282
14283 static struct hda_input_mux alc861vd_dallas_capture_source = {
14284         .num_items = 2,
14285         .items = {
14286                 { "Ext Mic", 0x0 },
14287                 { "Int Mic", 0x1 },
14288         },
14289 };
14290
14291 static struct hda_input_mux alc861vd_hp_capture_source = {
14292         .num_items = 2,
14293         .items = {
14294                 { "Front Mic", 0x0 },
14295                 { "ATAPI Mic", 0x1 },
14296         },
14297 };
14298
14299 /*
14300  * 2ch mode
14301  */
14302 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14303         { 2, NULL }
14304 };
14305
14306 /*
14307  * 6ch mode
14308  */
14309 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14310         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14311         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14312         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14313         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14314         { } /* end */
14315 };
14316
14317 /*
14318  * 8ch mode
14319  */
14320 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14321         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14322         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14323         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14324         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14325         { } /* end */
14326 };
14327
14328 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14329         { 6, alc861vd_6stack_ch6_init },
14330         { 8, alc861vd_6stack_ch8_init },
14331 };
14332
14333 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14334         {
14335                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14336                 .name = "Channel Mode",
14337                 .info = alc_ch_mode_info,
14338                 .get = alc_ch_mode_get,
14339                 .put = alc_ch_mode_put,
14340         },
14341         { } /* end */
14342 };
14343
14344 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14345  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14346  */
14347 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14348         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14349         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14350
14351         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14352         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14353
14354         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14355                                 HDA_OUTPUT),
14356         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14357                                 HDA_OUTPUT),
14358         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14359         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14360
14361         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14362         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14363
14364         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14365
14366         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14367         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14368         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14369
14370         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14371         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14372         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14373
14374         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14375         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14376
14377         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14378         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14379
14380         { } /* end */
14381 };
14382
14383 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14384         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14385         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14386
14387         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14388
14389         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14390         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14391         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14392
14393         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14394         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14395         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14396
14397         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14398         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14399
14400         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14401         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14402
14403         { } /* end */
14404 };
14405
14406 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14407         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14408         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14409         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14410
14411         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14412
14413         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14414         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14415         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14416
14417         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14418         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14419         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14420
14421         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14422         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14423
14424         { } /* end */
14425 };
14426
14427 /* Pin assignment: Speaker=0x14, HP = 0x15,
14428  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14429  */
14430 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14431         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14432         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14433         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14434         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14435         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14436         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14437         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14438         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14439         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14440         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14441         { } /* end */
14442 };
14443
14444 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14445  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14446  */
14447 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14448         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14449         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14450         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14451         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14452         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14453         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14454         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14455         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14456
14457         { } /* end */
14458 };
14459
14460 /*
14461  * generic initialization of ADC, input mixers and output mixers
14462  */
14463 static struct hda_verb alc861vd_volume_init_verbs[] = {
14464         /*
14465          * Unmute ADC0 and set the default input to mic-in
14466          */
14467         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14468         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14469
14470         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14471          * the analog-loopback mixer widget
14472          */
14473         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14474         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14475         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14476         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14477         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14478         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14479
14480         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14483         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14484         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14485
14486         /*
14487          * Set up output mixers (0x02 - 0x05)
14488          */
14489         /* set vol=0 to output mixers */
14490         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14491         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14492         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14493         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14494
14495         /* set up input amps for analog loopback */
14496         /* Amp Indices: DAC = 0, mixer = 1 */
14497         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14498         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14499         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14500         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14501         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14502         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14503         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14504         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14505
14506         { }
14507 };
14508
14509 /*
14510  * 3-stack pin configuration:
14511  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14512  */
14513 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14514         /*
14515          * Set pin mode and muting
14516          */
14517         /* set front pin widgets 0x14 for output */
14518         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14519         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14520         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14521
14522         /* Mic (rear) pin: input vref at 80% */
14523         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14524         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14525         /* Front Mic pin: input vref at 80% */
14526         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14527         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14528         /* Line In pin: input */
14529         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14530         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14531         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14532         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14533         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14534         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14535         /* CD pin widget for input */
14536         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14537
14538         { }
14539 };
14540
14541 /*
14542  * 6-stack pin configuration:
14543  */
14544 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14545         /*
14546          * Set pin mode and muting
14547          */
14548         /* set front pin widgets 0x14 for output */
14549         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14550         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14551         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14552
14553         /* Rear Pin: output 1 (0x0d) */
14554         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14555         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14556         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14557         /* CLFE Pin: output 2 (0x0e) */
14558         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14559         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14560         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14561         /* Side Pin: output 3 (0x0f) */
14562         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14563         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14564         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14565
14566         /* Mic (rear) pin: input vref at 80% */
14567         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14568         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14569         /* Front Mic pin: input vref at 80% */
14570         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14571         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14572         /* Line In pin: input */
14573         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14574         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14575         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14576         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14577         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14578         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14579         /* CD pin widget for input */
14580         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14581
14582         { }
14583 };
14584
14585 static struct hda_verb alc861vd_eapd_verbs[] = {
14586         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14587         { }
14588 };
14589
14590 static struct hda_verb alc660vd_eapd_verbs[] = {
14591         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14592         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14593         { }
14594 };
14595
14596 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
14597         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14598         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14599         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
14600         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14601         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14602         {}
14603 };
14604
14605 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
14606 {
14607         unsigned int present;
14608         unsigned char bits;
14609
14610         present = snd_hda_codec_read(codec, 0x18, 0,
14611                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14612         bits = present ? HDA_AMP_MUTE : 0;
14613         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
14614                                  HDA_AMP_MUTE, bits);
14615 }
14616
14617 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
14618 {
14619         struct alc_spec *spec = codec->spec;
14620
14621         spec->autocfg.hp_pins[0] = 0x1b;
14622         spec->autocfg.speaker_pins[0] = 0x14;
14623         alc_automute_amp(codec);
14624         alc861vd_lenovo_mic_automute(codec);
14625 }
14626
14627 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
14628                                         unsigned int res)
14629 {
14630         switch (res >> 26) {
14631         case ALC880_MIC_EVENT:
14632                 alc861vd_lenovo_mic_automute(codec);
14633                 break;
14634         default:
14635                 alc_automute_amp_unsol_event(codec, res);
14636                 break;
14637         }
14638 }
14639
14640 static struct hda_verb alc861vd_dallas_verbs[] = {
14641         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14642         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14643         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14644         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14645
14646         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14647         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14648         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14649         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14650         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14651         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14652         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14653         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14654
14655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14657         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14658         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14659         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14660         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14661         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14662         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14663
14664         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14665         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14666         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
14667         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14668         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14669         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14670         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14671         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14672
14673         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14674         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14675         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14676         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14677
14678         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14679         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14680         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14681
14682         { } /* end */
14683 };
14684
14685 /* toggle speaker-output according to the hp-jack state */
14686 static void alc861vd_dallas_init_hook(struct hda_codec *codec)
14687 {
14688         struct alc_spec *spec = codec->spec;
14689
14690         spec->autocfg.hp_pins[0] = 0x15;
14691         spec->autocfg.speaker_pins[0] = 0x14;
14692         alc_automute_amp(codec);
14693 }
14694
14695 #ifdef CONFIG_SND_HDA_POWER_SAVE
14696 #define alc861vd_loopbacks      alc880_loopbacks
14697 #endif
14698
14699 /* pcm configuration: identical with ALC880 */
14700 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
14701 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
14702 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
14703 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
14704
14705 /*
14706  * configuration and preset
14707  */
14708 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
14709         [ALC660VD_3ST]          = "3stack-660",
14710         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
14711         [ALC660VD_ASUS_V1S]     = "asus-v1s",
14712         [ALC861VD_3ST]          = "3stack",
14713         [ALC861VD_3ST_DIG]      = "3stack-digout",
14714         [ALC861VD_6ST_DIG]      = "6stack-digout",
14715         [ALC861VD_LENOVO]       = "lenovo",
14716         [ALC861VD_DALLAS]       = "dallas",
14717         [ALC861VD_HP]           = "hp",
14718         [ALC861VD_AUTO]         = "auto",
14719 };
14720
14721 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
14722         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
14723         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
14724         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
14725         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
14726         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
14727         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
14728         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
14729         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
14730         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
14731         SND_PCI_QUIRK(0x1179, 0xff01, "DALLAS", ALC861VD_DALLAS),
14732         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
14733         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
14734         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
14735         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
14736         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
14737         {}
14738 };
14739
14740 static struct alc_config_preset alc861vd_presets[] = {
14741         [ALC660VD_3ST] = {
14742                 .mixers = { alc861vd_3st_mixer },
14743                 .init_verbs = { alc861vd_volume_init_verbs,
14744                                  alc861vd_3stack_init_verbs },
14745                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14746                 .dac_nids = alc660vd_dac_nids,
14747                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14748                 .channel_mode = alc861vd_3stack_2ch_modes,
14749                 .input_mux = &alc861vd_capture_source,
14750         },
14751         [ALC660VD_3ST_DIG] = {
14752                 .mixers = { alc861vd_3st_mixer },
14753                 .init_verbs = { alc861vd_volume_init_verbs,
14754                                  alc861vd_3stack_init_verbs },
14755                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14756                 .dac_nids = alc660vd_dac_nids,
14757                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14758                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14759                 .channel_mode = alc861vd_3stack_2ch_modes,
14760                 .input_mux = &alc861vd_capture_source,
14761         },
14762         [ALC861VD_3ST] = {
14763                 .mixers = { alc861vd_3st_mixer },
14764                 .init_verbs = { alc861vd_volume_init_verbs,
14765                                  alc861vd_3stack_init_verbs },
14766                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14767                 .dac_nids = alc861vd_dac_nids,
14768                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14769                 .channel_mode = alc861vd_3stack_2ch_modes,
14770                 .input_mux = &alc861vd_capture_source,
14771         },
14772         [ALC861VD_3ST_DIG] = {
14773                 .mixers = { alc861vd_3st_mixer },
14774                 .init_verbs = { alc861vd_volume_init_verbs,
14775                                  alc861vd_3stack_init_verbs },
14776                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14777                 .dac_nids = alc861vd_dac_nids,
14778                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14779                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14780                 .channel_mode = alc861vd_3stack_2ch_modes,
14781                 .input_mux = &alc861vd_capture_source,
14782         },
14783         [ALC861VD_6ST_DIG] = {
14784                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
14785                 .init_verbs = { alc861vd_volume_init_verbs,
14786                                 alc861vd_6stack_init_verbs },
14787                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14788                 .dac_nids = alc861vd_dac_nids,
14789                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14790                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
14791                 .channel_mode = alc861vd_6stack_modes,
14792                 .input_mux = &alc861vd_capture_source,
14793         },
14794         [ALC861VD_LENOVO] = {
14795                 .mixers = { alc861vd_lenovo_mixer },
14796                 .init_verbs = { alc861vd_volume_init_verbs,
14797                                 alc861vd_3stack_init_verbs,
14798                                 alc861vd_eapd_verbs,
14799                                 alc861vd_lenovo_unsol_verbs },
14800                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14801                 .dac_nids = alc660vd_dac_nids,
14802                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14803                 .channel_mode = alc861vd_3stack_2ch_modes,
14804                 .input_mux = &alc861vd_capture_source,
14805                 .unsol_event = alc861vd_lenovo_unsol_event,
14806                 .init_hook = alc861vd_lenovo_init_hook,
14807         },
14808         [ALC861VD_DALLAS] = {
14809                 .mixers = { alc861vd_dallas_mixer },
14810                 .init_verbs = { alc861vd_dallas_verbs },
14811                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14812                 .dac_nids = alc861vd_dac_nids,
14813                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14814                 .channel_mode = alc861vd_3stack_2ch_modes,
14815                 .input_mux = &alc861vd_dallas_capture_source,
14816                 .unsol_event = alc_automute_amp_unsol_event,
14817                 .init_hook = alc861vd_dallas_init_hook,
14818         },
14819         [ALC861VD_HP] = {
14820                 .mixers = { alc861vd_hp_mixer },
14821                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
14822                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
14823                 .dac_nids = alc861vd_dac_nids,
14824                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14825                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14826                 .channel_mode = alc861vd_3stack_2ch_modes,
14827                 .input_mux = &alc861vd_hp_capture_source,
14828                 .unsol_event = alc_automute_amp_unsol_event,
14829                 .init_hook = alc861vd_dallas_init_hook,
14830         },
14831         [ALC660VD_ASUS_V1S] = {
14832                 .mixers = { alc861vd_lenovo_mixer },
14833                 .init_verbs = { alc861vd_volume_init_verbs,
14834                                 alc861vd_3stack_init_verbs,
14835                                 alc861vd_eapd_verbs,
14836                                 alc861vd_lenovo_unsol_verbs },
14837                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
14838                 .dac_nids = alc660vd_dac_nids,
14839                 .dig_out_nid = ALC861VD_DIGOUT_NID,
14840                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
14841                 .channel_mode = alc861vd_3stack_2ch_modes,
14842                 .input_mux = &alc861vd_capture_source,
14843                 .unsol_event = alc861vd_lenovo_unsol_event,
14844                 .init_hook = alc861vd_lenovo_init_hook,
14845         },
14846 };
14847
14848 /*
14849  * BIOS auto configuration
14850  */
14851 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
14852                                 hda_nid_t nid, int pin_type, int dac_idx)
14853 {
14854         alc_set_pin_output(codec, nid, pin_type);
14855 }
14856
14857 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
14858 {
14859         struct alc_spec *spec = codec->spec;
14860         int i;
14861
14862         for (i = 0; i <= HDA_SIDE; i++) {
14863                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14864                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14865                 if (nid)
14866                         alc861vd_auto_set_output_and_unmute(codec, nid,
14867                                                             pin_type, i);
14868         }
14869 }
14870
14871
14872 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
14873 {
14874         struct alc_spec *spec = codec->spec;
14875         hda_nid_t pin;
14876
14877         pin = spec->autocfg.hp_pins[0];
14878         if (pin) /* connect to front and use dac 0 */
14879                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
14880         pin = spec->autocfg.speaker_pins[0];
14881         if (pin)
14882                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
14883 }
14884
14885 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
14886 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
14887
14888 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
14889 {
14890         struct alc_spec *spec = codec->spec;
14891         int i;
14892
14893         for (i = 0; i < AUTO_PIN_LAST; i++) {
14894                 hda_nid_t nid = spec->autocfg.input_pins[i];
14895                 if (alc861vd_is_input_pin(nid)) {
14896                         alc_set_input_pin(codec, nid, i);
14897                         if (nid != ALC861VD_PIN_CD_NID &&
14898                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
14899                                 snd_hda_codec_write(codec, nid, 0,
14900                                                 AC_VERB_SET_AMP_GAIN_MUTE,
14901                                                 AMP_OUT_MUTE);
14902                 }
14903         }
14904 }
14905
14906 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
14907
14908 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
14909 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
14910
14911 /* add playback controls from the parsed DAC table */
14912 /* Based on ALC880 version. But ALC861VD has separate,
14913  * different NIDs for mute/unmute switch and volume control */
14914 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
14915                                              const struct auto_pin_cfg *cfg)
14916 {
14917         char name[32];
14918         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
14919         hda_nid_t nid_v, nid_s;
14920         int i, err;
14921
14922         for (i = 0; i < cfg->line_outs; i++) {
14923                 if (!spec->multiout.dac_nids[i])
14924                         continue;
14925                 nid_v = alc861vd_idx_to_mixer_vol(
14926                                 alc880_dac_to_idx(
14927                                         spec->multiout.dac_nids[i]));
14928                 nid_s = alc861vd_idx_to_mixer_switch(
14929                                 alc880_dac_to_idx(
14930                                         spec->multiout.dac_nids[i]));
14931
14932                 if (i == 2) {
14933                         /* Center/LFE */
14934                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14935                                           "Center Playback Volume",
14936                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
14937                                                               HDA_OUTPUT));
14938                         if (err < 0)
14939                                 return err;
14940                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
14941                                           "LFE Playback Volume",
14942                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
14943                                                               HDA_OUTPUT));
14944                         if (err < 0)
14945                                 return err;
14946                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14947                                           "Center Playback Switch",
14948                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
14949                                                               HDA_INPUT));
14950                         if (err < 0)
14951                                 return err;
14952                         err = add_control(spec, ALC_CTL_BIND_MUTE,
14953                                           "LFE Playback Switch",
14954                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
14955                                                               HDA_INPUT));
14956                         if (err < 0)
14957                                 return err;
14958                 } else {
14959                         sprintf(name, "%s Playback Volume", chname[i]);
14960                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
14961                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
14962                                                               HDA_OUTPUT));
14963                         if (err < 0)
14964                                 return err;
14965                         sprintf(name, "%s Playback Switch", chname[i]);
14966                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
14967                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
14968                                                               HDA_INPUT));
14969                         if (err < 0)
14970                                 return err;
14971                 }
14972         }
14973         return 0;
14974 }
14975
14976 /* add playback controls for speaker and HP outputs */
14977 /* Based on ALC880 version. But ALC861VD has separate,
14978  * different NIDs for mute/unmute switch and volume control */
14979 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
14980                                         hda_nid_t pin, const char *pfx)
14981 {
14982         hda_nid_t nid_v, nid_s;
14983         int err;
14984         char name[32];
14985
14986         if (!pin)
14987                 return 0;
14988
14989         if (alc880_is_fixed_pin(pin)) {
14990                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
14991                 /* specify the DAC as the extra output */
14992                 if (!spec->multiout.hp_nid)
14993                         spec->multiout.hp_nid = nid_v;
14994                 else
14995                         spec->multiout.extra_out_nid[0] = nid_v;
14996                 /* control HP volume/switch on the output mixer amp */
14997                 nid_v = alc861vd_idx_to_mixer_vol(
14998                                 alc880_fixed_pin_idx(pin));
14999                 nid_s = alc861vd_idx_to_mixer_switch(
15000                                 alc880_fixed_pin_idx(pin));
15001
15002                 sprintf(name, "%s Playback Volume", pfx);
15003                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15004                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15005                 if (err < 0)
15006                         return err;
15007                 sprintf(name, "%s Playback Switch", pfx);
15008                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15009                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15010                 if (err < 0)
15011                         return err;
15012         } else if (alc880_is_multi_pin(pin)) {
15013                 /* set manual connection */
15014                 /* we have only a switch on HP-out PIN */
15015                 sprintf(name, "%s Playback Switch", pfx);
15016                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15017                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15018                 if (err < 0)
15019                         return err;
15020         }
15021         return 0;
15022 }
15023
15024 /* parse the BIOS configuration and set up the alc_spec
15025  * return 1 if successful, 0 if the proper config is not found,
15026  * or a negative error code
15027  * Based on ALC880 version - had to change it to override
15028  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15029 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15030 {
15031         struct alc_spec *spec = codec->spec;
15032         int err;
15033         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15034
15035         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15036                                            alc861vd_ignore);
15037         if (err < 0)
15038                 return err;
15039         if (!spec->autocfg.line_outs)
15040                 return 0; /* can't find valid BIOS pin config */
15041
15042         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15043         if (err < 0)
15044                 return err;
15045         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15046         if (err < 0)
15047                 return err;
15048         err = alc861vd_auto_create_extra_out(spec,
15049                                              spec->autocfg.speaker_pins[0],
15050                                              "Speaker");
15051         if (err < 0)
15052                 return err;
15053         err = alc861vd_auto_create_extra_out(spec,
15054                                              spec->autocfg.hp_pins[0],
15055                                              "Headphone");
15056         if (err < 0)
15057                 return err;
15058         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15059         if (err < 0)
15060                 return err;
15061
15062         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15063
15064         if (spec->autocfg.dig_outs)
15065                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15066
15067         if (spec->kctls.list)
15068                 add_mixer(spec, spec->kctls.list);
15069
15070         add_verb(spec, alc861vd_volume_init_verbs);
15071
15072         spec->num_mux_defs = 1;
15073         spec->input_mux = &spec->private_imux[0];
15074
15075         err = alc_auto_add_mic_boost(codec);
15076         if (err < 0)
15077                 return err;
15078
15079         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15080
15081         return 1;
15082 }
15083
15084 /* additional initialization for auto-configuration model */
15085 static void alc861vd_auto_init(struct hda_codec *codec)
15086 {
15087         struct alc_spec *spec = codec->spec;
15088         alc861vd_auto_init_multi_out(codec);
15089         alc861vd_auto_init_hp_out(codec);
15090         alc861vd_auto_init_analog_input(codec);
15091         alc861vd_auto_init_input_src(codec);
15092         if (spec->unsol_event)
15093                 alc_inithook(codec);
15094 }
15095
15096 static int patch_alc861vd(struct hda_codec *codec)
15097 {
15098         struct alc_spec *spec;
15099         int err, board_config;
15100
15101         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15102         if (spec == NULL)
15103                 return -ENOMEM;
15104
15105         codec->spec = spec;
15106
15107         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15108                                                   alc861vd_models,
15109                                                   alc861vd_cfg_tbl);
15110
15111         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15112                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
15113                        "trying auto-probe from BIOS...\n", codec->chip_name);
15114                 board_config = ALC861VD_AUTO;
15115         }
15116
15117         if (board_config == ALC861VD_AUTO) {
15118                 /* automatic parse from the BIOS config */
15119                 err = alc861vd_parse_auto_config(codec);
15120                 if (err < 0) {
15121                         alc_free(codec);
15122                         return err;
15123                 } else if (!err) {
15124                         printk(KERN_INFO
15125                                "hda_codec: Cannot set up configuration "
15126                                "from BIOS.  Using base mode...\n");
15127                         board_config = ALC861VD_3ST;
15128                 }
15129         }
15130
15131         err = snd_hda_attach_beep_device(codec, 0x23);
15132         if (err < 0) {
15133                 alc_free(codec);
15134                 return err;
15135         }
15136
15137         if (board_config != ALC861VD_AUTO)
15138                 setup_preset(spec, &alc861vd_presets[board_config]);
15139
15140         if (codec->vendor_id == 0x10ec0660) {
15141                 /* always turn on EAPD */
15142                 add_verb(spec, alc660vd_eapd_verbs);
15143         }
15144
15145         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15146         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15147
15148         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15149         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15150
15151         spec->adc_nids = alc861vd_adc_nids;
15152         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15153         spec->capsrc_nids = alc861vd_capsrc_nids;
15154
15155         set_capture_mixer(spec);
15156         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15157
15158         spec->vmaster_nid = 0x02;
15159
15160         codec->patch_ops = alc_patch_ops;
15161
15162         if (board_config == ALC861VD_AUTO)
15163                 spec->init_hook = alc861vd_auto_init;
15164 #ifdef CONFIG_SND_HDA_POWER_SAVE
15165         if (!spec->loopback.amplist)
15166                 spec->loopback.amplist = alc861vd_loopbacks;
15167 #endif
15168         codec->proc_widget_hook = print_realtek_coef;
15169
15170         return 0;
15171 }
15172
15173 /*
15174  * ALC662 support
15175  *
15176  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15177  * configuration.  Each pin widget can choose any input DACs and a mixer.
15178  * Each ADC is connected from a mixer of all inputs.  This makes possible
15179  * 6-channel independent captures.
15180  *
15181  * In addition, an independent DAC for the multi-playback (not used in this
15182  * driver yet).
15183  */
15184 #define ALC662_DIGOUT_NID       0x06
15185 #define ALC662_DIGIN_NID        0x0a
15186
15187 static hda_nid_t alc662_dac_nids[4] = {
15188         /* front, rear, clfe, rear_surr */
15189         0x02, 0x03, 0x04
15190 };
15191
15192 static hda_nid_t alc272_dac_nids[2] = {
15193         0x02, 0x03
15194 };
15195
15196 static hda_nid_t alc662_adc_nids[1] = {
15197         /* ADC1-2 */
15198         0x09,
15199 };
15200
15201 static hda_nid_t alc272_adc_nids[1] = {
15202         /* ADC1-2 */
15203         0x08,
15204 };
15205
15206 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15207 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15208
15209
15210 /* input MUX */
15211 /* FIXME: should be a matrix-type input source selection */
15212 static struct hda_input_mux alc662_capture_source = {
15213         .num_items = 4,
15214         .items = {
15215                 { "Mic", 0x0 },
15216                 { "Front Mic", 0x1 },
15217                 { "Line", 0x2 },
15218                 { "CD", 0x4 },
15219         },
15220 };
15221
15222 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15223         .num_items = 2,
15224         .items = {
15225                 { "Mic", 0x1 },
15226                 { "Line", 0x2 },
15227         },
15228 };
15229
15230 static struct hda_input_mux alc662_eeepc_capture_source = {
15231         .num_items = 2,
15232         .items = {
15233                 { "i-Mic", 0x1 },
15234                 { "e-Mic", 0x0 },
15235         },
15236 };
15237
15238 static struct hda_input_mux alc663_capture_source = {
15239         .num_items = 3,
15240         .items = {
15241                 { "Mic", 0x0 },
15242                 { "Front Mic", 0x1 },
15243                 { "Line", 0x2 },
15244         },
15245 };
15246
15247 static struct hda_input_mux alc663_m51va_capture_source = {
15248         .num_items = 2,
15249         .items = {
15250                 { "Ext-Mic", 0x0 },
15251                 { "D-Mic", 0x9 },
15252         },
15253 };
15254
15255 #if 1 /* set to 0 for testing other input sources below */
15256 static struct hda_input_mux alc272_nc10_capture_source = {
15257         .num_items = 2,
15258         .items = {
15259                 { "Autoselect Mic", 0x0 },
15260                 { "Internal Mic", 0x1 },
15261         },
15262 };
15263 #else
15264 static struct hda_input_mux alc272_nc10_capture_source = {
15265         .num_items = 16,
15266         .items = {
15267                 { "Autoselect Mic", 0x0 },
15268                 { "Internal Mic", 0x1 },
15269                 { "In-0x02", 0x2 },
15270                 { "In-0x03", 0x3 },
15271                 { "In-0x04", 0x4 },
15272                 { "In-0x05", 0x5 },
15273                 { "In-0x06", 0x6 },
15274                 { "In-0x07", 0x7 },
15275                 { "In-0x08", 0x8 },
15276                 { "In-0x09", 0x9 },
15277                 { "In-0x0a", 0x0a },
15278                 { "In-0x0b", 0x0b },
15279                 { "In-0x0c", 0x0c },
15280                 { "In-0x0d", 0x0d },
15281                 { "In-0x0e", 0x0e },
15282                 { "In-0x0f", 0x0f },
15283         },
15284 };
15285 #endif
15286
15287 /*
15288  * 2ch mode
15289  */
15290 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15291         { 2, NULL }
15292 };
15293
15294 /*
15295  * 2ch mode
15296  */
15297 static struct hda_verb alc662_3ST_ch2_init[] = {
15298         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15299         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15300         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15301         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15302         { } /* end */
15303 };
15304
15305 /*
15306  * 6ch mode
15307  */
15308 static struct hda_verb alc662_3ST_ch6_init[] = {
15309         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15310         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15311         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15312         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15313         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15314         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15315         { } /* end */
15316 };
15317
15318 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15319         { 2, alc662_3ST_ch2_init },
15320         { 6, alc662_3ST_ch6_init },
15321 };
15322
15323 /*
15324  * 2ch mode
15325  */
15326 static struct hda_verb alc662_sixstack_ch6_init[] = {
15327         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15328         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15329         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15330         { } /* end */
15331 };
15332
15333 /*
15334  * 6ch mode
15335  */
15336 static struct hda_verb alc662_sixstack_ch8_init[] = {
15337         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15338         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15339         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15340         { } /* end */
15341 };
15342
15343 static struct hda_channel_mode alc662_5stack_modes[2] = {
15344         { 2, alc662_sixstack_ch6_init },
15345         { 6, alc662_sixstack_ch8_init },
15346 };
15347
15348 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15349  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15350  */
15351
15352 static struct snd_kcontrol_new alc662_base_mixer[] = {
15353         /* output mixer control */
15354         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15355         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15356         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15357         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15358         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15359         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15360         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15361         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15362         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15363
15364         /*Input mixer control */
15365         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15366         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15367         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15368         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15369         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15370         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15371         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15372         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15373         { } /* end */
15374 };
15375
15376 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15377         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15378         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15379         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15380         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15381         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15382         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15383         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15384         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15385         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15386         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15387         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15388         { } /* end */
15389 };
15390
15391 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15392         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15393         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15394         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15395         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15396         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15397         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15398         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15399         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15400         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15401         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15402         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15403         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15404         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15405         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15406         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15407         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15408         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15409         { } /* end */
15410 };
15411
15412 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15413         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15414         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15415         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15416         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15418         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15419         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15420         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15421         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15422         { } /* end */
15423 };
15424
15425 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15426         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15427         ALC262_HIPPO_MASTER_SWITCH,
15428
15429         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15430         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15431         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15432
15433         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15434         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15435         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15436         { } /* end */
15437 };
15438
15439 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15440         ALC262_HIPPO_MASTER_SWITCH,
15441         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15442         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15443         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15444         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15445         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15446         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15447         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15448         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15449         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15450         { } /* end */
15451 };
15452
15453 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15454         .ops = &snd_hda_bind_vol,
15455         .values = {
15456                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15457                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15458                 0
15459         },
15460 };
15461
15462 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15463         .ops = &snd_hda_bind_sw,
15464         .values = {
15465                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15466                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15467                 0
15468         },
15469 };
15470
15471 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15472         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15473         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15474         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15475         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15476         { } /* end */
15477 };
15478
15479 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15480         .ops = &snd_hda_bind_sw,
15481         .values = {
15482                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15483                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15484                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15485                 0
15486         },
15487 };
15488
15489 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15490         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15491         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15492         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15493         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15494         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15495         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15496
15497         { } /* end */
15498 };
15499
15500 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15501         .ops = &snd_hda_bind_sw,
15502         .values = {
15503                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15504                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15505                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15506                 0
15507         },
15508 };
15509
15510 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15511         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15512         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15513         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15514         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15515         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15516         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15517         { } /* end */
15518 };
15519
15520 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15521         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15522         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15523         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15524         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15525         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15526         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15527         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15528         { } /* end */
15529 };
15530
15531 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15532         .ops = &snd_hda_bind_vol,
15533         .values = {
15534                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15535                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15536                 0
15537         },
15538 };
15539
15540 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15541         .ops = &snd_hda_bind_sw,
15542         .values = {
15543                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15544                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15545                 0
15546         },
15547 };
15548
15549 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15550         HDA_BIND_VOL("Master Playback Volume",
15551                                 &alc663_asus_two_bind_master_vol),
15552         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15553         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15554         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15555         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15556         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15557         { } /* end */
15558 };
15559
15560 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15561         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15562         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15563         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15564         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15565         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15566         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15567         { } /* end */
15568 };
15569
15570 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15571         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15572         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15573         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15574         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15575         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15576
15577         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15578         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15579         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15580         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15581         { } /* end */
15582 };
15583
15584 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15585         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15586         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15587         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15588
15589         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15590         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15591         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15592         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15593         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15594         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15595         { } /* end */
15596 };
15597
15598 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
15599         {
15600                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15601                 .name = "Channel Mode",
15602                 .info = alc_ch_mode_info,
15603                 .get = alc_ch_mode_get,
15604                 .put = alc_ch_mode_put,
15605         },
15606         { } /* end */
15607 };
15608
15609 static struct hda_verb alc662_init_verbs[] = {
15610         /* ADC: mute amp left and right */
15611         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15612         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15613         /* Front mixer: unmute input/output amp left and right (volume = 0) */
15614
15615         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15616         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15617         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15618         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15619         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15620
15621         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15622         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15623         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15624         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15625         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15626         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15627
15628         /* Front Pin: output 0 (0x0c) */
15629         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15630         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15631
15632         /* Rear Pin: output 1 (0x0d) */
15633         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15634         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15635
15636         /* CLFE Pin: output 2 (0x0e) */
15637         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15638         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15639
15640         /* Mic (rear) pin: input vref at 80% */
15641         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15642         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15643         /* Front Mic pin: input vref at 80% */
15644         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15645         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15646         /* Line In pin: input */
15647         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15648         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15649         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15650         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15651         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15652         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15653         /* CD pin widget for input */
15654         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15655
15656         /* FIXME: use matrix-type input source selection */
15657         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15658         /* Input mixer */
15659         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15660         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15661
15662         /* always trun on EAPD */
15663         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15664         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15665
15666         { }
15667 };
15668
15669 static struct hda_verb alc662_sue_init_verbs[] = {
15670         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15671         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15672         {}
15673 };
15674
15675 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
15676         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15677         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15678         {}
15679 };
15680
15681 /* Set Unsolicited Event*/
15682 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
15683         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15684         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15685         {}
15686 };
15687
15688 /*
15689  * generic initialization of ADC, input mixers and output mixers
15690  */
15691 static struct hda_verb alc662_auto_init_verbs[] = {
15692         /*
15693          * Unmute ADC and set the default input to mic-in
15694          */
15695         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15696         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15697
15698         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
15699          * mixer widget
15700          * Note: PASD motherboards uses the Line In 2 as the input for front
15701          * panel mic (mic 2)
15702          */
15703         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15704         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15705         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15706         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15707         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15708         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15709
15710         /*
15711          * Set up output mixers (0x0c - 0x0f)
15712          */
15713         /* set vol=0 to output mixers */
15714         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15715         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15716         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15717
15718         /* set up input amps for analog loopback */
15719         /* Amp Indices: DAC = 0, mixer = 1 */
15720         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15721         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15722         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15723         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15724         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15725         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15726
15727
15728         /* FIXME: use matrix-type input source selection */
15729         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
15730         /* Input mixer */
15731         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15732         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15733         { }
15734 };
15735
15736 /* additional verbs for ALC663 */
15737 static struct hda_verb alc663_auto_init_verbs[] = {
15738         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15739         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15740         { }
15741 };
15742
15743 static struct hda_verb alc663_m51va_init_verbs[] = {
15744         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15745         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15746         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15747         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15748         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15749         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15750         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15751         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15752         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15753         {}
15754 };
15755
15756 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
15757         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15758         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15759         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15760         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15761         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15762         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15763         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15764         {}
15765 };
15766
15767 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
15768         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15769         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15770         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15771         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15772         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15773         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15774         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15775         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15776         {}
15777 };
15778
15779 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
15780         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15781         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15782         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15783         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15784         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15785         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15786         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15787         {}
15788 };
15789
15790 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
15791         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15792         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15793         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15794         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15795         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15796         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15797         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
15798         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15799         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15800         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15801         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15802         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15803         {}
15804 };
15805
15806 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
15807         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15808         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15809         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15810         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15811         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15812         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15813         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15814         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15815         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15816         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15817         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15818         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15819         {}
15820 };
15821
15822 static struct hda_verb alc663_g71v_init_verbs[] = {
15823         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15824         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
15825         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
15826
15827         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15828         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15829         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15830
15831         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
15832         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
15833         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
15834         {}
15835 };
15836
15837 static struct hda_verb alc663_g50v_init_verbs[] = {
15838         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15839         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15840         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
15841
15842         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15843         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15844         {}
15845 };
15846
15847 static struct hda_verb alc662_ecs_init_verbs[] = {
15848         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
15849         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15850         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15851         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15852         {}
15853 };
15854
15855 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
15856         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15857         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15858         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15859         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15860         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15861         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15862         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15863         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15864         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15865         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15866         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15867         {}
15868 };
15869
15870 static struct hda_verb alc272_dell_init_verbs[] = {
15871         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15872         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15873         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15874         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15875         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15876         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15877         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
15878         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15879         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
15880         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15881         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15882         {}
15883 };
15884
15885 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
15886         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
15887         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
15888         { } /* end */
15889 };
15890
15891 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
15892         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
15893         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
15894         { } /* end */
15895 };
15896
15897 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
15898 {
15899         unsigned int present;
15900         unsigned char bits;
15901
15902         present = snd_hda_codec_read(codec, 0x14, 0,
15903                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15904         bits = present ? HDA_AMP_MUTE : 0;
15905         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15906                                  HDA_AMP_MUTE, bits);
15907 }
15908
15909 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
15910 {
15911         unsigned int present;
15912         unsigned char bits;
15913
15914         present = snd_hda_codec_read(codec, 0x1b, 0,
15915                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15916         bits = present ? HDA_AMP_MUTE : 0;
15917         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
15918                                  HDA_AMP_MUTE, bits);
15919         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
15920                                  HDA_AMP_MUTE, bits);
15921 }
15922
15923 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
15924                                            unsigned int res)
15925 {
15926         if ((res >> 26) == ALC880_HP_EVENT)
15927                 alc662_lenovo_101e_all_automute(codec);
15928         if ((res >> 26) == ALC880_FRONT_EVENT)
15929                 alc662_lenovo_101e_ispeaker_automute(codec);
15930 }
15931
15932 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
15933 {
15934         unsigned int present;
15935
15936         present = snd_hda_codec_read(codec, 0x18, 0,
15937                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15938         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15939                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15940         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15941                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
15942         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15943                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15944         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15945                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
15946 }
15947
15948 /* unsolicited event for HP jack sensing */
15949 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
15950                                      unsigned int res)
15951 {
15952         if ((res >> 26) == ALC880_MIC_EVENT)
15953                 alc662_eeepc_mic_automute(codec);
15954         else
15955                 alc262_hippo_unsol_event(codec, res);
15956 }
15957
15958 static void alc662_eeepc_inithook(struct hda_codec *codec)
15959 {
15960         alc262_hippo1_init_hook(codec);
15961         alc662_eeepc_mic_automute(codec);
15962 }
15963
15964 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
15965 {
15966         struct alc_spec *spec = codec->spec;
15967
15968         spec->autocfg.hp_pins[0] = 0x14;
15969         spec->autocfg.speaker_pins[0] = 0x1b;
15970         alc262_hippo_master_update(codec);
15971 }
15972
15973 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
15974 {
15975         unsigned int present;
15976         unsigned char bits;
15977
15978         present = snd_hda_codec_read(codec, 0x21, 0,
15979                         AC_VERB_GET_PIN_SENSE, 0)
15980                         & AC_PINSENSE_PRESENCE;
15981         bits = present ? HDA_AMP_MUTE : 0;
15982         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15983                                 AMP_IN_MUTE(0), bits);
15984         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
15985                                 AMP_IN_MUTE(0), bits);
15986 }
15987
15988 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
15989 {
15990         unsigned int present;
15991         unsigned char bits;
15992
15993         present = snd_hda_codec_read(codec, 0x21, 0,
15994                         AC_VERB_GET_PIN_SENSE, 0)
15995                         & AC_PINSENSE_PRESENCE;
15996         bits = present ? HDA_AMP_MUTE : 0;
15997         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
15998                                 AMP_IN_MUTE(0), bits);
15999         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16000                                 AMP_IN_MUTE(0), bits);
16001         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16002                                 AMP_IN_MUTE(0), bits);
16003         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16004                                 AMP_IN_MUTE(0), bits);
16005 }
16006
16007 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16008 {
16009         unsigned int present;
16010         unsigned char bits;
16011
16012         present = snd_hda_codec_read(codec, 0x15, 0,
16013                         AC_VERB_GET_PIN_SENSE, 0)
16014                         & AC_PINSENSE_PRESENCE;
16015         bits = present ? HDA_AMP_MUTE : 0;
16016         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16017                                 AMP_IN_MUTE(0), bits);
16018         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16019                                 AMP_IN_MUTE(0), bits);
16020         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16021                                 AMP_IN_MUTE(0), bits);
16022         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16023                                 AMP_IN_MUTE(0), bits);
16024 }
16025
16026 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16027 {
16028         unsigned int present;
16029         unsigned char bits;
16030
16031         present = snd_hda_codec_read(codec, 0x1b, 0,
16032                         AC_VERB_GET_PIN_SENSE, 0)
16033                         & AC_PINSENSE_PRESENCE;
16034         bits = present ? 0 : PIN_OUT;
16035         snd_hda_codec_write(codec, 0x14, 0,
16036                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16037 }
16038
16039 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16040 {
16041         unsigned int present1, present2;
16042
16043         present1 = snd_hda_codec_read(codec, 0x21, 0,
16044                         AC_VERB_GET_PIN_SENSE, 0)
16045                         & AC_PINSENSE_PRESENCE;
16046         present2 = snd_hda_codec_read(codec, 0x15, 0,
16047                         AC_VERB_GET_PIN_SENSE, 0)
16048                         & AC_PINSENSE_PRESENCE;
16049
16050         if (present1 || present2) {
16051                 snd_hda_codec_write_cache(codec, 0x14, 0,
16052                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16053         } else {
16054                 snd_hda_codec_write_cache(codec, 0x14, 0,
16055                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16056         }
16057 }
16058
16059 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16060 {
16061         unsigned int present1, present2;
16062
16063         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16064                                 AC_VERB_GET_PIN_SENSE, 0)
16065                                 & AC_PINSENSE_PRESENCE;
16066         present2 = snd_hda_codec_read(codec, 0x15, 0,
16067                                 AC_VERB_GET_PIN_SENSE, 0)
16068                                 & AC_PINSENSE_PRESENCE;
16069
16070         if (present1 || present2) {
16071                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16072                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16073                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16074                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16075         } else {
16076                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16077                                 AMP_IN_MUTE(0), 0);
16078                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16079                                 AMP_IN_MUTE(0), 0);
16080         }
16081 }
16082
16083 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16084 {
16085         unsigned int present;
16086
16087         present = snd_hda_codec_read(codec, 0x18, 0,
16088                         AC_VERB_GET_PIN_SENSE, 0)
16089                         & AC_PINSENSE_PRESENCE;
16090         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16091                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16092         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16093                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16094         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16095                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16096         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16097                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16098 }
16099
16100 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16101                                            unsigned int res)
16102 {
16103         switch (res >> 26) {
16104         case ALC880_HP_EVENT:
16105                 alc663_m51va_speaker_automute(codec);
16106                 break;
16107         case ALC880_MIC_EVENT:
16108                 alc663_m51va_mic_automute(codec);
16109                 break;
16110         }
16111 }
16112
16113 static void alc663_m51va_inithook(struct hda_codec *codec)
16114 {
16115         alc663_m51va_speaker_automute(codec);
16116         alc663_m51va_mic_automute(codec);
16117 }
16118
16119 /* ***************** Mode1 ******************************/
16120 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16121                                            unsigned int res)
16122 {
16123         switch (res >> 26) {
16124         case ALC880_HP_EVENT:
16125                 alc663_m51va_speaker_automute(codec);
16126                 break;
16127         case ALC880_MIC_EVENT:
16128                 alc662_eeepc_mic_automute(codec);
16129                 break;
16130         }
16131 }
16132
16133 static void alc663_mode1_inithook(struct hda_codec *codec)
16134 {
16135         alc663_m51va_speaker_automute(codec);
16136         alc662_eeepc_mic_automute(codec);
16137 }
16138 /* ***************** Mode2 ******************************/
16139 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16140                                            unsigned int res)
16141 {
16142         switch (res >> 26) {
16143         case ALC880_HP_EVENT:
16144                 alc662_f5z_speaker_automute(codec);
16145                 break;
16146         case ALC880_MIC_EVENT:
16147                 alc662_eeepc_mic_automute(codec);
16148                 break;
16149         }
16150 }
16151
16152 static void alc662_mode2_inithook(struct hda_codec *codec)
16153 {
16154         alc662_f5z_speaker_automute(codec);
16155         alc662_eeepc_mic_automute(codec);
16156 }
16157 /* ***************** Mode3 ******************************/
16158 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16159                                            unsigned int res)
16160 {
16161         switch (res >> 26) {
16162         case ALC880_HP_EVENT:
16163                 alc663_two_hp_m1_speaker_automute(codec);
16164                 break;
16165         case ALC880_MIC_EVENT:
16166                 alc662_eeepc_mic_automute(codec);
16167                 break;
16168         }
16169 }
16170
16171 static void alc663_mode3_inithook(struct hda_codec *codec)
16172 {
16173         alc663_two_hp_m1_speaker_automute(codec);
16174         alc662_eeepc_mic_automute(codec);
16175 }
16176 /* ***************** Mode4 ******************************/
16177 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16178                                            unsigned int res)
16179 {
16180         switch (res >> 26) {
16181         case ALC880_HP_EVENT:
16182                 alc663_21jd_two_speaker_automute(codec);
16183                 break;
16184         case ALC880_MIC_EVENT:
16185                 alc662_eeepc_mic_automute(codec);
16186                 break;
16187         }
16188 }
16189
16190 static void alc663_mode4_inithook(struct hda_codec *codec)
16191 {
16192         alc663_21jd_two_speaker_automute(codec);
16193         alc662_eeepc_mic_automute(codec);
16194 }
16195 /* ***************** Mode5 ******************************/
16196 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16197                                            unsigned int res)
16198 {
16199         switch (res >> 26) {
16200         case ALC880_HP_EVENT:
16201                 alc663_15jd_two_speaker_automute(codec);
16202                 break;
16203         case ALC880_MIC_EVENT:
16204                 alc662_eeepc_mic_automute(codec);
16205                 break;
16206         }
16207 }
16208
16209 static void alc663_mode5_inithook(struct hda_codec *codec)
16210 {
16211         alc663_15jd_two_speaker_automute(codec);
16212         alc662_eeepc_mic_automute(codec);
16213 }
16214 /* ***************** Mode6 ******************************/
16215 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16216                                            unsigned int res)
16217 {
16218         switch (res >> 26) {
16219         case ALC880_HP_EVENT:
16220                 alc663_two_hp_m2_speaker_automute(codec);
16221                 break;
16222         case ALC880_MIC_EVENT:
16223                 alc662_eeepc_mic_automute(codec);
16224                 break;
16225         }
16226 }
16227
16228 static void alc663_mode6_inithook(struct hda_codec *codec)
16229 {
16230         alc663_two_hp_m2_speaker_automute(codec);
16231         alc662_eeepc_mic_automute(codec);
16232 }
16233
16234 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16235 {
16236         unsigned int present;
16237         unsigned char bits;
16238
16239         present = snd_hda_codec_read(codec, 0x21, 0,
16240                                      AC_VERB_GET_PIN_SENSE, 0)
16241                 & AC_PINSENSE_PRESENCE;
16242         bits = present ? HDA_AMP_MUTE : 0;
16243         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16244                                  HDA_AMP_MUTE, bits);
16245         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16246                                  HDA_AMP_MUTE, bits);
16247 }
16248
16249 static void alc663_g71v_front_automute(struct hda_codec *codec)
16250 {
16251         unsigned int present;
16252         unsigned char bits;
16253
16254         present = snd_hda_codec_read(codec, 0x15, 0,
16255                                      AC_VERB_GET_PIN_SENSE, 0)
16256                 & AC_PINSENSE_PRESENCE;
16257         bits = present ? HDA_AMP_MUTE : 0;
16258         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16259                                  HDA_AMP_MUTE, bits);
16260 }
16261
16262 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16263                                            unsigned int res)
16264 {
16265         switch (res >> 26) {
16266         case ALC880_HP_EVENT:
16267                 alc663_g71v_hp_automute(codec);
16268                 break;
16269         case ALC880_FRONT_EVENT:
16270                 alc663_g71v_front_automute(codec);
16271                 break;
16272         case ALC880_MIC_EVENT:
16273                 alc662_eeepc_mic_automute(codec);
16274                 break;
16275         }
16276 }
16277
16278 static void alc663_g71v_inithook(struct hda_codec *codec)
16279 {
16280         alc663_g71v_front_automute(codec);
16281         alc663_g71v_hp_automute(codec);
16282         alc662_eeepc_mic_automute(codec);
16283 }
16284
16285 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16286                                            unsigned int res)
16287 {
16288         switch (res >> 26) {
16289         case ALC880_HP_EVENT:
16290                 alc663_m51va_speaker_automute(codec);
16291                 break;
16292         case ALC880_MIC_EVENT:
16293                 alc662_eeepc_mic_automute(codec);
16294                 break;
16295         }
16296 }
16297
16298 static void alc663_g50v_inithook(struct hda_codec *codec)
16299 {
16300         alc663_m51va_speaker_automute(codec);
16301         alc662_eeepc_mic_automute(codec);
16302 }
16303
16304 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16305         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16306         ALC262_HIPPO_MASTER_SWITCH,
16307
16308         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16309         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16310         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16311
16312         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16313         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16314         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16315         { } /* end */
16316 };
16317
16318 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16319         /* Master Playback automatically created from Speaker and Headphone */
16320         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16321         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16322         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16323         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16324
16325         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16326         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16327         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16328
16329         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16330         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16331         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16332         { } /* end */
16333 };
16334
16335 #ifdef CONFIG_SND_HDA_POWER_SAVE
16336 #define alc662_loopbacks        alc880_loopbacks
16337 #endif
16338
16339
16340 /* pcm configuration: identical with ALC880 */
16341 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16342 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16343 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16344 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16345
16346 /*
16347  * configuration and preset
16348  */
16349 static const char *alc662_models[ALC662_MODEL_LAST] = {
16350         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16351         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16352         [ALC662_3ST_6ch]        = "3stack-6ch",
16353         [ALC662_5ST_DIG]        = "6stack-dig",
16354         [ALC662_LENOVO_101E]    = "lenovo-101e",
16355         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16356         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16357         [ALC662_ECS] = "ecs",
16358         [ALC663_ASUS_M51VA] = "m51va",
16359         [ALC663_ASUS_G71V] = "g71v",
16360         [ALC663_ASUS_H13] = "h13",
16361         [ALC663_ASUS_G50V] = "g50v",
16362         [ALC663_ASUS_MODE1] = "asus-mode1",
16363         [ALC662_ASUS_MODE2] = "asus-mode2",
16364         [ALC663_ASUS_MODE3] = "asus-mode3",
16365         [ALC663_ASUS_MODE4] = "asus-mode4",
16366         [ALC663_ASUS_MODE5] = "asus-mode5",
16367         [ALC663_ASUS_MODE6] = "asus-mode6",
16368         [ALC272_DELL]           = "dell",
16369         [ALC272_DELL_ZM1]       = "dell-zm1",
16370         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16371         [ALC662_AUTO]           = "auto",
16372 };
16373
16374 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16375         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16376         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16377         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16378         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16379         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16380         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16381         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16382         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16383         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16384         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16385         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16386         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16387         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16388         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16389         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16390         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16391         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16392         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16393         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16394         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16395         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16396         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16397         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16398         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16399         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16400         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16401         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16402         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16403         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16404         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16405         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16406         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16407         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16408         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16409         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16410         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16411         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16412         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16413         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16414         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16415         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16416         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16417         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16418         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16419         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16420         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16421         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16422         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16423         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16424         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16425         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16426         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16427                       ALC662_3ST_6ch_DIG),
16428         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16429         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16430                       ALC662_3ST_6ch_DIG),
16431         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16432         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16433         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16434         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16435                                         ALC662_3ST_6ch_DIG),
16436         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16437                            ALC663_ASUS_H13),
16438         {}
16439 };
16440
16441 static struct alc_config_preset alc662_presets[] = {
16442         [ALC662_3ST_2ch_DIG] = {
16443                 .mixers = { alc662_3ST_2ch_mixer },
16444                 .init_verbs = { alc662_init_verbs },
16445                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16446                 .dac_nids = alc662_dac_nids,
16447                 .dig_out_nid = ALC662_DIGOUT_NID,
16448                 .dig_in_nid = ALC662_DIGIN_NID,
16449                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16450                 .channel_mode = alc662_3ST_2ch_modes,
16451                 .input_mux = &alc662_capture_source,
16452         },
16453         [ALC662_3ST_6ch_DIG] = {
16454                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16455                 .init_verbs = { alc662_init_verbs },
16456                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16457                 .dac_nids = alc662_dac_nids,
16458                 .dig_out_nid = ALC662_DIGOUT_NID,
16459                 .dig_in_nid = ALC662_DIGIN_NID,
16460                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16461                 .channel_mode = alc662_3ST_6ch_modes,
16462                 .need_dac_fix = 1,
16463                 .input_mux = &alc662_capture_source,
16464         },
16465         [ALC662_3ST_6ch] = {
16466                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16467                 .init_verbs = { alc662_init_verbs },
16468                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16469                 .dac_nids = alc662_dac_nids,
16470                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16471                 .channel_mode = alc662_3ST_6ch_modes,
16472                 .need_dac_fix = 1,
16473                 .input_mux = &alc662_capture_source,
16474         },
16475         [ALC662_5ST_DIG] = {
16476                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16477                 .init_verbs = { alc662_init_verbs },
16478                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16479                 .dac_nids = alc662_dac_nids,
16480                 .dig_out_nid = ALC662_DIGOUT_NID,
16481                 .dig_in_nid = ALC662_DIGIN_NID,
16482                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16483                 .channel_mode = alc662_5stack_modes,
16484                 .input_mux = &alc662_capture_source,
16485         },
16486         [ALC662_LENOVO_101E] = {
16487                 .mixers = { alc662_lenovo_101e_mixer },
16488                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16489                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16490                 .dac_nids = alc662_dac_nids,
16491                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16492                 .channel_mode = alc662_3ST_2ch_modes,
16493                 .input_mux = &alc662_lenovo_101e_capture_source,
16494                 .unsol_event = alc662_lenovo_101e_unsol_event,
16495                 .init_hook = alc662_lenovo_101e_all_automute,
16496         },
16497         [ALC662_ASUS_EEEPC_P701] = {
16498                 .mixers = { alc662_eeepc_p701_mixer },
16499                 .init_verbs = { alc662_init_verbs,
16500                                 alc662_eeepc_sue_init_verbs },
16501                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16502                 .dac_nids = alc662_dac_nids,
16503                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16504                 .channel_mode = alc662_3ST_2ch_modes,
16505                 .input_mux = &alc662_eeepc_capture_source,
16506                 .unsol_event = alc662_eeepc_unsol_event,
16507                 .init_hook = alc662_eeepc_inithook,
16508         },
16509         [ALC662_ASUS_EEEPC_EP20] = {
16510                 .mixers = { alc662_eeepc_ep20_mixer,
16511                             alc662_chmode_mixer },
16512                 .init_verbs = { alc662_init_verbs,
16513                                 alc662_eeepc_ep20_sue_init_verbs },
16514                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16515                 .dac_nids = alc662_dac_nids,
16516                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16517                 .channel_mode = alc662_3ST_6ch_modes,
16518                 .input_mux = &alc662_lenovo_101e_capture_source,
16519                 .unsol_event = alc662_eeepc_unsol_event,
16520                 .init_hook = alc662_eeepc_ep20_inithook,
16521         },
16522         [ALC662_ECS] = {
16523                 .mixers = { alc662_ecs_mixer },
16524                 .init_verbs = { alc662_init_verbs,
16525                                 alc662_ecs_init_verbs },
16526                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16527                 .dac_nids = alc662_dac_nids,
16528                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16529                 .channel_mode = alc662_3ST_2ch_modes,
16530                 .input_mux = &alc662_eeepc_capture_source,
16531                 .unsol_event = alc662_eeepc_unsol_event,
16532                 .init_hook = alc662_eeepc_inithook,
16533         },
16534         [ALC663_ASUS_M51VA] = {
16535                 .mixers = { alc663_m51va_mixer },
16536                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16537                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16538                 .dac_nids = alc662_dac_nids,
16539                 .dig_out_nid = ALC662_DIGOUT_NID,
16540                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16541                 .channel_mode = alc662_3ST_2ch_modes,
16542                 .input_mux = &alc663_m51va_capture_source,
16543                 .unsol_event = alc663_m51va_unsol_event,
16544                 .init_hook = alc663_m51va_inithook,
16545         },
16546         [ALC663_ASUS_G71V] = {
16547                 .mixers = { alc663_g71v_mixer },
16548                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16549                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16550                 .dac_nids = alc662_dac_nids,
16551                 .dig_out_nid = ALC662_DIGOUT_NID,
16552                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16553                 .channel_mode = alc662_3ST_2ch_modes,
16554                 .input_mux = &alc662_eeepc_capture_source,
16555                 .unsol_event = alc663_g71v_unsol_event,
16556                 .init_hook = alc663_g71v_inithook,
16557         },
16558         [ALC663_ASUS_H13] = {
16559                 .mixers = { alc663_m51va_mixer },
16560                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16561                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16562                 .dac_nids = alc662_dac_nids,
16563                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16564                 .channel_mode = alc662_3ST_2ch_modes,
16565                 .input_mux = &alc663_m51va_capture_source,
16566                 .unsol_event = alc663_m51va_unsol_event,
16567                 .init_hook = alc663_m51va_inithook,
16568         },
16569         [ALC663_ASUS_G50V] = {
16570                 .mixers = { alc663_g50v_mixer },
16571                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16572                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16573                 .dac_nids = alc662_dac_nids,
16574                 .dig_out_nid = ALC662_DIGOUT_NID,
16575                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16576                 .channel_mode = alc662_3ST_6ch_modes,
16577                 .input_mux = &alc663_capture_source,
16578                 .unsol_event = alc663_g50v_unsol_event,
16579                 .init_hook = alc663_g50v_inithook,
16580         },
16581         [ALC663_ASUS_MODE1] = {
16582                 .mixers = { alc663_m51va_mixer },
16583                 .cap_mixer = alc662_auto_capture_mixer,
16584                 .init_verbs = { alc662_init_verbs,
16585                                 alc663_21jd_amic_init_verbs },
16586                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16587                 .hp_nid = 0x03,
16588                 .dac_nids = alc662_dac_nids,
16589                 .dig_out_nid = ALC662_DIGOUT_NID,
16590                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16591                 .channel_mode = alc662_3ST_2ch_modes,
16592                 .input_mux = &alc662_eeepc_capture_source,
16593                 .unsol_event = alc663_mode1_unsol_event,
16594                 .init_hook = alc663_mode1_inithook,
16595         },
16596         [ALC662_ASUS_MODE2] = {
16597                 .mixers = { alc662_1bjd_mixer },
16598                 .cap_mixer = alc662_auto_capture_mixer,
16599                 .init_verbs = { alc662_init_verbs,
16600                                 alc662_1bjd_amic_init_verbs },
16601                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16602                 .dac_nids = alc662_dac_nids,
16603                 .dig_out_nid = ALC662_DIGOUT_NID,
16604                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16605                 .channel_mode = alc662_3ST_2ch_modes,
16606                 .input_mux = &alc662_eeepc_capture_source,
16607                 .unsol_event = alc662_mode2_unsol_event,
16608                 .init_hook = alc662_mode2_inithook,
16609         },
16610         [ALC663_ASUS_MODE3] = {
16611                 .mixers = { alc663_two_hp_m1_mixer },
16612                 .cap_mixer = alc662_auto_capture_mixer,
16613                 .init_verbs = { alc662_init_verbs,
16614                                 alc663_two_hp_amic_m1_init_verbs },
16615                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16616                 .hp_nid = 0x03,
16617                 .dac_nids = alc662_dac_nids,
16618                 .dig_out_nid = ALC662_DIGOUT_NID,
16619                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16620                 .channel_mode = alc662_3ST_2ch_modes,
16621                 .input_mux = &alc662_eeepc_capture_source,
16622                 .unsol_event = alc663_mode3_unsol_event,
16623                 .init_hook = alc663_mode3_inithook,
16624         },
16625         [ALC663_ASUS_MODE4] = {
16626                 .mixers = { alc663_asus_21jd_clfe_mixer },
16627                 .cap_mixer = alc662_auto_capture_mixer,
16628                 .init_verbs = { alc662_init_verbs,
16629                                 alc663_21jd_amic_init_verbs},
16630                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16631                 .hp_nid = 0x03,
16632                 .dac_nids = alc662_dac_nids,
16633                 .dig_out_nid = ALC662_DIGOUT_NID,
16634                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16635                 .channel_mode = alc662_3ST_2ch_modes,
16636                 .input_mux = &alc662_eeepc_capture_source,
16637                 .unsol_event = alc663_mode4_unsol_event,
16638                 .init_hook = alc663_mode4_inithook,
16639         },
16640         [ALC663_ASUS_MODE5] = {
16641                 .mixers = { alc663_asus_15jd_clfe_mixer },
16642                 .cap_mixer = alc662_auto_capture_mixer,
16643                 .init_verbs = { alc662_init_verbs,
16644                                 alc663_15jd_amic_init_verbs },
16645                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16646                 .hp_nid = 0x03,
16647                 .dac_nids = alc662_dac_nids,
16648                 .dig_out_nid = ALC662_DIGOUT_NID,
16649                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16650                 .channel_mode = alc662_3ST_2ch_modes,
16651                 .input_mux = &alc662_eeepc_capture_source,
16652                 .unsol_event = alc663_mode5_unsol_event,
16653                 .init_hook = alc663_mode5_inithook,
16654         },
16655         [ALC663_ASUS_MODE6] = {
16656                 .mixers = { alc663_two_hp_m2_mixer },
16657                 .cap_mixer = alc662_auto_capture_mixer,
16658                 .init_verbs = { alc662_init_verbs,
16659                                 alc663_two_hp_amic_m2_init_verbs },
16660                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16661                 .hp_nid = 0x03,
16662                 .dac_nids = alc662_dac_nids,
16663                 .dig_out_nid = ALC662_DIGOUT_NID,
16664                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16665                 .channel_mode = alc662_3ST_2ch_modes,
16666                 .input_mux = &alc662_eeepc_capture_source,
16667                 .unsol_event = alc663_mode6_unsol_event,
16668                 .init_hook = alc663_mode6_inithook,
16669         },
16670         [ALC272_DELL] = {
16671                 .mixers = { alc663_m51va_mixer },
16672                 .cap_mixer = alc272_auto_capture_mixer,
16673                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
16674                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16675                 .dac_nids = alc662_dac_nids,
16676                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16677                 .adc_nids = alc272_adc_nids,
16678                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
16679                 .capsrc_nids = alc272_capsrc_nids,
16680                 .channel_mode = alc662_3ST_2ch_modes,
16681                 .input_mux = &alc663_m51va_capture_source,
16682                 .unsol_event = alc663_m51va_unsol_event,
16683                 .init_hook = alc663_m51va_inithook,
16684         },
16685         [ALC272_DELL_ZM1] = {
16686                 .mixers = { alc663_m51va_mixer },
16687                 .cap_mixer = alc662_auto_capture_mixer,
16688                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
16689                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16690                 .dac_nids = alc662_dac_nids,
16691                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16692                 .adc_nids = alc662_adc_nids,
16693                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
16694                 .capsrc_nids = alc662_capsrc_nids,
16695                 .channel_mode = alc662_3ST_2ch_modes,
16696                 .input_mux = &alc663_m51va_capture_source,
16697                 .unsol_event = alc663_m51va_unsol_event,
16698                 .init_hook = alc663_m51va_inithook,
16699         },
16700         [ALC272_SAMSUNG_NC10] = {
16701                 .mixers = { alc272_nc10_mixer },
16702                 .init_verbs = { alc662_init_verbs,
16703                                 alc663_21jd_amic_init_verbs },
16704                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
16705                 .dac_nids = alc272_dac_nids,
16706                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16707                 .channel_mode = alc662_3ST_2ch_modes,
16708                 .input_mux = &alc272_nc10_capture_source,
16709                 .unsol_event = alc663_mode4_unsol_event,
16710                 .init_hook = alc663_mode4_inithook,
16711         },
16712 };
16713
16714
16715 /*
16716  * BIOS auto configuration
16717  */
16718
16719 /* add playback controls from the parsed DAC table */
16720 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
16721                                              const struct auto_pin_cfg *cfg)
16722 {
16723         char name[32];
16724         static const char *chname[4] = {
16725                 "Front", "Surround", NULL /*CLFE*/, "Side"
16726         };
16727         hda_nid_t nid;
16728         int i, err;
16729
16730         for (i = 0; i < cfg->line_outs; i++) {
16731                 if (!spec->multiout.dac_nids[i])
16732                         continue;
16733                 nid = alc880_idx_to_dac(i);
16734                 if (i == 2) {
16735                         /* Center/LFE */
16736                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16737                                           "Center Playback Volume",
16738                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
16739                                                               HDA_OUTPUT));
16740                         if (err < 0)
16741                                 return err;
16742                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
16743                                           "LFE Playback Volume",
16744                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
16745                                                               HDA_OUTPUT));
16746                         if (err < 0)
16747                                 return err;
16748                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16749                                           "Center Playback Switch",
16750                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
16751                                                               HDA_INPUT));
16752                         if (err < 0)
16753                                 return err;
16754                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
16755                                           "LFE Playback Switch",
16756                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
16757                                                               HDA_INPUT));
16758                         if (err < 0)
16759                                 return err;
16760                 } else {
16761                         sprintf(name, "%s Playback Volume", chname[i]);
16762                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16763                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
16764                                                               HDA_OUTPUT));
16765                         if (err < 0)
16766                                 return err;
16767                         sprintf(name, "%s Playback Switch", chname[i]);
16768                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16769                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
16770                                                     3, 0, HDA_INPUT));
16771                         if (err < 0)
16772                                 return err;
16773                 }
16774         }
16775         return 0;
16776 }
16777
16778 /* add playback controls for speaker and HP outputs */
16779 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
16780                                         const char *pfx)
16781 {
16782         hda_nid_t nid;
16783         int err;
16784         char name[32];
16785
16786         if (!pin)
16787                 return 0;
16788
16789         if (pin == 0x17) {
16790                 /* ALC663 has a mono output pin on 0x17 */
16791                 sprintf(name, "%s Playback Switch", pfx);
16792                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16793                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
16794                 return err;
16795         }
16796
16797         if (alc880_is_fixed_pin(pin)) {
16798                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16799                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
16800                 /* specify the DAC as the extra output */
16801                 if (!spec->multiout.hp_nid)
16802                         spec->multiout.hp_nid = nid;
16803                 else
16804                         spec->multiout.extra_out_nid[0] = nid;
16805                 /* control HP volume/switch on the output mixer amp */
16806                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16807                 sprintf(name, "%s Playback Volume", pfx);
16808                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
16809                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
16810                 if (err < 0)
16811                         return err;
16812                 sprintf(name, "%s Playback Switch", pfx);
16813                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
16814                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
16815                 if (err < 0)
16816                         return err;
16817         } else if (alc880_is_multi_pin(pin)) {
16818                 /* set manual connection */
16819                 /* we have only a switch on HP-out PIN */
16820                 sprintf(name, "%s Playback Switch", pfx);
16821                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
16822                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16823                 if (err < 0)
16824                         return err;
16825         }
16826         return 0;
16827 }
16828
16829 /* return the index of the src widget from the connection list of the nid.
16830  * return -1 if not found
16831  */
16832 static int alc662_input_pin_idx(struct hda_codec *codec, hda_nid_t nid,
16833                                 hda_nid_t src)
16834 {
16835         hda_nid_t conn_list[HDA_MAX_CONNECTIONS];
16836         int i, conns;
16837
16838         conns = snd_hda_get_connections(codec, nid, conn_list,
16839                                         ARRAY_SIZE(conn_list));
16840         if (conns < 0)
16841                 return -1;
16842         for (i = 0; i < conns; i++)
16843                 if (conn_list[i] == src)
16844                         return i;
16845         return -1;
16846 }
16847
16848 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
16849 {
16850         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
16851         return (pincap & AC_PINCAP_IN) != 0;
16852 }
16853
16854 /* create playback/capture controls for input pins */
16855 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
16856                                                 const struct auto_pin_cfg *cfg)
16857 {
16858         struct alc_spec *spec = codec->spec;
16859         struct hda_input_mux *imux = &spec->private_imux[0];
16860         int i, err, idx;
16861
16862         for (i = 0; i < AUTO_PIN_LAST; i++) {
16863                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
16864                         idx = alc662_input_pin_idx(codec, 0x0b,
16865                                                    cfg->input_pins[i]);
16866                         if (idx >= 0) {
16867                                 err = new_analog_input(spec, cfg->input_pins[i],
16868                                                        auto_pin_cfg_labels[i],
16869                                                        idx, 0x0b);
16870                                 if (err < 0)
16871                                         return err;
16872                         }
16873                         idx = alc662_input_pin_idx(codec, 0x22,
16874                                                    cfg->input_pins[i]);
16875                         if (idx >= 0) {
16876                                 imux->items[imux->num_items].label =
16877                                         auto_pin_cfg_labels[i];
16878                                 imux->items[imux->num_items].index = idx;
16879                                 imux->num_items++;
16880                         }
16881                 }
16882         }
16883         return 0;
16884 }
16885
16886 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
16887                                               hda_nid_t nid, int pin_type,
16888                                               int dac_idx)
16889 {
16890         alc_set_pin_output(codec, nid, pin_type);
16891         /* need the manual connection? */
16892         if (alc880_is_multi_pin(nid)) {
16893                 struct alc_spec *spec = codec->spec;
16894                 int idx = alc880_multi_pin_idx(nid);
16895                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
16896                                     AC_VERB_SET_CONNECT_SEL,
16897                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
16898         }
16899 }
16900
16901 static void alc662_auto_init_multi_out(struct hda_codec *codec)
16902 {
16903         struct alc_spec *spec = codec->spec;
16904         int i;
16905
16906         for (i = 0; i <= HDA_SIDE; i++) {
16907                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16908                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16909                 if (nid)
16910                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
16911                                                           i);
16912         }
16913 }
16914
16915 static void alc662_auto_init_hp_out(struct hda_codec *codec)
16916 {
16917         struct alc_spec *spec = codec->spec;
16918         hda_nid_t pin;
16919
16920         pin = spec->autocfg.hp_pins[0];
16921         if (pin) /* connect to front */
16922                 /* use dac 0 */
16923                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16924         pin = spec->autocfg.speaker_pins[0];
16925         if (pin)
16926                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16927 }
16928
16929 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
16930
16931 static void alc662_auto_init_analog_input(struct hda_codec *codec)
16932 {
16933         struct alc_spec *spec = codec->spec;
16934         int i;
16935
16936         for (i = 0; i < AUTO_PIN_LAST; i++) {
16937                 hda_nid_t nid = spec->autocfg.input_pins[i];
16938                 if (alc662_is_input_pin(codec, nid)) {
16939                         alc_set_input_pin(codec, nid, i);
16940                         if (nid != ALC662_PIN_CD_NID &&
16941                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16942                                 snd_hda_codec_write(codec, nid, 0,
16943                                                     AC_VERB_SET_AMP_GAIN_MUTE,
16944                                                     AMP_OUT_MUTE);
16945                 }
16946         }
16947 }
16948
16949 #define alc662_auto_init_input_src      alc882_auto_init_input_src
16950
16951 static int alc662_parse_auto_config(struct hda_codec *codec)
16952 {
16953         struct alc_spec *spec = codec->spec;
16954         int err;
16955         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
16956
16957         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16958                                            alc662_ignore);
16959         if (err < 0)
16960                 return err;
16961         if (!spec->autocfg.line_outs)
16962                 return 0; /* can't find valid BIOS pin config */
16963
16964         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16965         if (err < 0)
16966                 return err;
16967         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
16968         if (err < 0)
16969                 return err;
16970         err = alc662_auto_create_extra_out(spec,
16971                                            spec->autocfg.speaker_pins[0],
16972                                            "Speaker");
16973         if (err < 0)
16974                 return err;
16975         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
16976                                            "Headphone");
16977         if (err < 0)
16978                 return err;
16979         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
16980         if (err < 0)
16981                 return err;
16982
16983         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16984
16985         if (spec->autocfg.dig_outs)
16986                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
16987
16988         if (spec->kctls.list)
16989                 add_mixer(spec, spec->kctls.list);
16990
16991         spec->num_mux_defs = 1;
16992         spec->input_mux = &spec->private_imux[0];
16993
16994         add_verb(spec, alc662_auto_init_verbs);
16995         if (codec->vendor_id == 0x10ec0663)
16996                 add_verb(spec, alc663_auto_init_verbs);
16997
16998         err = alc_auto_add_mic_boost(codec);
16999         if (err < 0)
17000                 return err;
17001
17002         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17003
17004         return 1;
17005 }
17006
17007 /* additional initialization for auto-configuration model */
17008 static void alc662_auto_init(struct hda_codec *codec)
17009 {
17010         struct alc_spec *spec = codec->spec;
17011         alc662_auto_init_multi_out(codec);
17012         alc662_auto_init_hp_out(codec);
17013         alc662_auto_init_analog_input(codec);
17014         alc662_auto_init_input_src(codec);
17015         if (spec->unsol_event)
17016                 alc_inithook(codec);
17017 }
17018
17019 static int patch_alc662(struct hda_codec *codec)
17020 {
17021         struct alc_spec *spec;
17022         int err, board_config;
17023
17024         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17025         if (!spec)
17026                 return -ENOMEM;
17027
17028         codec->spec = spec;
17029
17030         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17031
17032         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17033                                                   alc662_models,
17034                                                   alc662_cfg_tbl);
17035         if (board_config < 0) {
17036                 printk(KERN_INFO "hda_codec: Unknown model for %s, "
17037                        "trying auto-probe from BIOS...\n", codec->chip_name);
17038                 board_config = ALC662_AUTO;
17039         }
17040
17041         if (board_config == ALC662_AUTO) {
17042                 /* automatic parse from the BIOS config */
17043                 err = alc662_parse_auto_config(codec);
17044                 if (err < 0) {
17045                         alc_free(codec);
17046                         return err;
17047                 } else if (!err) {
17048                         printk(KERN_INFO
17049                                "hda_codec: Cannot set up configuration "
17050                                "from BIOS.  Using base mode...\n");
17051                         board_config = ALC662_3ST_2ch_DIG;
17052                 }
17053         }
17054
17055         err = snd_hda_attach_beep_device(codec, 0x1);
17056         if (err < 0) {
17057                 alc_free(codec);
17058                 return err;
17059         }
17060
17061         if (board_config != ALC662_AUTO)
17062                 setup_preset(spec, &alc662_presets[board_config]);
17063
17064         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17065         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17066
17067         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17068         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17069
17070         spec->adc_nids = alc662_adc_nids;
17071         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17072         spec->capsrc_nids = alc662_capsrc_nids;
17073
17074         if (!spec->cap_mixer)
17075                 set_capture_mixer(spec);
17076         if (codec->vendor_id == 0x10ec0662)
17077                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17078         else
17079                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17080
17081         spec->vmaster_nid = 0x02;
17082
17083         codec->patch_ops = alc_patch_ops;
17084         if (board_config == ALC662_AUTO)
17085                 spec->init_hook = alc662_auto_init;
17086 #ifdef CONFIG_SND_HDA_POWER_SAVE
17087         if (!spec->loopback.amplist)
17088                 spec->loopback.amplist = alc662_loopbacks;
17089 #endif
17090         codec->proc_widget_hook = print_realtek_coef;
17091
17092         return 0;
17093 }
17094
17095 /*
17096  * patch entries
17097  */
17098 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17099         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17100         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17101         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17102         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17103         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17104         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17105         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17106           .patch = patch_alc861 },
17107         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17108         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17109         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17110         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17111           .patch = patch_alc882 },
17112         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17113           .patch = patch_alc662 },
17114         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17115         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17116         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17117         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17118         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17119           .patch = patch_alc882 },
17120         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17121           .patch = patch_alc882 },
17122         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17123         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17124         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17125           .patch = patch_alc882 },
17126         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
17127         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17128         {} /* terminator */
17129 };
17130
17131 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17132
17133 MODULE_LICENSE("GPL");
17134 MODULE_DESCRIPTION("Realtek HD-audio codec");
17135
17136 static struct hda_codec_preset_list realtek_list = {
17137         .preset = snd_hda_preset_realtek,
17138         .owner = THIS_MODULE,
17139 };
17140
17141 static int __init patch_realtek_init(void)
17142 {
17143         return snd_hda_add_codec_preset(&realtek_list);
17144 }
17145
17146 static void __exit patch_realtek_exit(void)
17147 {
17148         snd_hda_delete_codec_preset(&realtek_list);
17149 }
17150
17151 module_init(patch_realtek_init)
17152 module_exit(patch_realtek_exit)