SAFE public projects git trees. - safe/jmp/linux-2.6/blob - sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_AMIC,
 135         ALC269_ASUS_DMIC,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC663_ASUS_MODE7,
 192         ALC663_ASUS_MODE8,
 193         ALC272_DELL,
 194         ALC272_DELL_ZM1,
 195         ALC272_SAMSUNG_NC10,
 196         ALC662_AUTO,
 197         ALC662_MODEL_LAST,
 198 };
 199
 200 /* ALC882 models */
 201 enum {
 202         ALC882_3ST_DIG,
 203         ALC882_6ST_DIG,
 204         ALC882_ARIMA,
 205         ALC882_W2JC,
 206         ALC882_TARGA,
 207         ALC882_ASUS_A7J,
 208         ALC882_ASUS_A7M,
 209         ALC885_MACPRO,
 210         ALC885_MBP3,
 211         ALC885_MB5,
 212         ALC885_IMAC24,
 213         ALC885_IMAC91,
 214         ALC883_3ST_2ch_DIG,
 215         ALC883_3ST_6ch_DIG,
 216         ALC883_3ST_6ch,
 217         ALC883_6ST_DIG,
 218         ALC883_TARGA_DIG,
 219         ALC883_TARGA_2ch_DIG,
 220         ALC883_TARGA_8ch_DIG,
 221         ALC883_ACER,
 222         ALC883_ACER_ASPIRE,
 223         ALC888_ACER_ASPIRE_4930G,
 224         ALC888_ACER_ASPIRE_6530G,
 225         ALC888_ACER_ASPIRE_8930G,
 226         ALC888_ACER_ASPIRE_7730G,
 227         ALC883_MEDION,
 228         ALC883_MEDION_MD2,
 229         ALC883_LAPTOP_EAPD,
 230         ALC883_LENOVO_101E_2ch,
 231         ALC883_LENOVO_NB0763,
 232         ALC888_LENOVO_MS7195_DIG,
 233         ALC888_LENOVO_SKY,
 234         ALC883_HAIER_W66,
 235         ALC888_3ST_HP,
 236         ALC888_6ST_DELL,
 237         ALC883_MITAC,
 238         ALC883_CLEVO_M540R,
 239         ALC883_CLEVO_M720,
 240         ALC883_FUJITSU_PI2515,
 241         ALC888_FUJITSU_XA3530,
 242         ALC883_3ST_6ch_INTEL,
 243         ALC889A_INTEL,
 244         ALC889_INTEL,
 245         ALC888_ASUS_M90V,
 246         ALC888_ASUS_EEE1601,
 247         ALC889A_MB31,
 248         ALC1200_ASUS_P5Q,
 249         ALC883_SONY_VAIO_TT,
 250         ALC882_AUTO,
 251         ALC882_MODEL_LAST,
 252 };
 253
 254 /* for GPIO Poll */
 255 #define GPIO_MASK       0x03
 256
 257 /* extra amp-initialization sequence types */
 258 enum {
 259         ALC_INIT_NONE,
 260         ALC_INIT_DEFAULT,
 261         ALC_INIT_GPIO1,
 262         ALC_INIT_GPIO2,
 263         ALC_INIT_GPIO3,
 264 };
 265
 266 struct alc_mic_route {
 267         hda_nid_t pin;
 268         unsigned char mux_idx;
 269         unsigned char amix_idx;
 270 };
 271
 272 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 273
 274 struct alc_spec {
 275         /* codec parameterization */
 276         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 277         unsigned int num_mixers;
 278         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 279         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 280
 281         const struct hda_verb *init_verbs[10];  /* initialization verbs
 282                                                  * don't forget NULL
 283                                                  * termination!
 284                                                  */
 285         unsigned int num_init_verbs;
 286
 287         char stream_name_analog[32];    /* analog PCM stream */
 288         struct hda_pcm_stream *stream_analog_playback;
 289         struct hda_pcm_stream *stream_analog_capture;
 290         struct hda_pcm_stream *stream_analog_alt_playback;
 291         struct hda_pcm_stream *stream_analog_alt_capture;
 292
 293         char stream_name_digital[32];   /* digital PCM stream */
 294         struct hda_pcm_stream *stream_digital_playback;
 295         struct hda_pcm_stream *stream_digital_capture;
 296
 297         /* playback */
 298         struct hda_multi_out multiout;  /* playback set-up
 299                                          * max_channels, dacs must be set
 300                                          * dig_out_nid and hp_nid are optional
 301                                          */
 302         hda_nid_t alt_dac_nid;
 303         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 304         int dig_out_type;
 305
 306         /* capture */
 307         unsigned int num_adc_nids;
 308         hda_nid_t *adc_nids;
 309         hda_nid_t *capsrc_nids;
 310         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 311
 312         /* capture source */
 313         unsigned int num_mux_defs;
 314         const struct hda_input_mux *input_mux;
 315         unsigned int cur_mux[3];
 316         struct alc_mic_route ext_mic;
 317         struct alc_mic_route int_mic;
 318
 319         /* channel model */
 320         const struct hda_channel_mode *channel_mode;
 321         int num_channel_mode;
 322         int need_dac_fix;
 323         int const_channel_count;
 324         int ext_channel_count;
 325
 326         /* PCM information */
 327         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 328
 329         /* dynamic controls, init_verbs and input_mux */
 330         struct auto_pin_cfg autocfg;
 331         struct snd_array kctls;
 332         struct hda_input_mux private_imux[3];
 333         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 334         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 335         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 336
 337         /* hooks */
 338         void (*init_hook)(struct hda_codec *codec);
 339         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 340 #ifdef CONFIG_SND_HDA_POWER_SAVE
 341         void (*power_hook)(struct hda_codec *codec, int power);
 342 #endif
 343
 344         /* for pin sensing */
 345         unsigned int sense_updated: 1;
 346         unsigned int jack_present: 1;
 347         unsigned int master_sw: 1;
 348         unsigned int auto_mic:1;
 349
 350         /* other flags */
 351         unsigned int no_analog :1; /* digital I/O only */
 352         int init_amp;
 353
 354         /* for virtual master */
 355         hda_nid_t vmaster_nid;
 356 #ifdef CONFIG_SND_HDA_POWER_SAVE
 357         struct hda_loopback_check loopback;
 358 #endif
 359
 360         /* for PLL fix */
 361         hda_nid_t pll_nid;
 362         unsigned int pll_coef_idx, pll_coef_bit;
 363 };
 364
 365 /*
 366  * configuration template - to be copied to the spec instance
 367  */
 368 struct alc_config_preset {
 369         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 370                                              * with spec
 371                                              */
 372         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 373         const struct hda_verb *init_verbs[5];
 374         unsigned int num_dacs;
 375         hda_nid_t *dac_nids;
 376         hda_nid_t dig_out_nid;          /* optional */
 377         hda_nid_t hp_nid;               /* optional */
 378         hda_nid_t *slave_dig_outs;
 379         unsigned int num_adc_nids;
 380         hda_nid_t *adc_nids;
 381         hda_nid_t *capsrc_nids;
 382         hda_nid_t dig_in_nid;
 383         unsigned int num_channel_mode;
 384         const struct hda_channel_mode *channel_mode;
 385         int need_dac_fix;
 386         int const_channel_count;
 387         unsigned int num_mux_defs;
 388         const struct hda_input_mux *input_mux;
 389         void (*unsol_event)(struct hda_codec *, unsigned int);
 390         void (*setup)(struct hda_codec *);
 391         void (*init_hook)(struct hda_codec *);
 392 #ifdef CONFIG_SND_HDA_POWER_SAVE
 393         struct hda_amp_list *loopbacks;
 394         void (*power_hook)(struct hda_codec *codec, int power);
 395 #endif
 396 };
 397
 398
 399 /*
 400  * input MUX handling
 401  */
 402 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 403                              struct snd_ctl_elem_info *uinfo)
 404 {
 405         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 406         struct alc_spec *spec = codec->spec;
 407         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 408         if (mux_idx >= spec->num_mux_defs)
 409                 mux_idx = 0;
 410         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 411 }
 412
 413 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 414                             struct snd_ctl_elem_value *ucontrol)
 415 {
 416         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 417         struct alc_spec *spec = codec->spec;
 418         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 419
 420         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 421         return 0;
 422 }
 423
 424 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 425                             struct snd_ctl_elem_value *ucontrol)
 426 {
 427         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 428         struct alc_spec *spec = codec->spec;
 429         const struct hda_input_mux *imux;
 430         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 431         unsigned int mux_idx;
 432         hda_nid_t nid = spec->capsrc_nids ?
 433                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 434         unsigned int type;
 435
 436         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 437         imux = &spec->input_mux[mux_idx];
 438
 439         type = get_wcaps_type(get_wcaps(codec, nid));
 440         if (type == AC_WID_AUD_MIX) {
 441                 /* Matrix-mixer style (e.g. ALC882) */
 442                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 443                 unsigned int i, idx;
 444
 445                 idx = ucontrol->value.enumerated.item[0];
 446                 if (idx >= imux->num_items)
 447                         idx = imux->num_items - 1;
 448                 if (*cur_val == idx)
 449                         return 0;
 450                 for (i = 0; i < imux->num_items; i++) {
 451                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 452                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 453                                                  imux->items[i].index,
 454                                                  HDA_AMP_MUTE, v);
 455                 }
 456                 *cur_val = idx;
 457                 return 1;
 458         } else {
 459                 /* MUX style (e.g. ALC880) */
 460                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 461                                              &spec->cur_mux[adc_idx]);
 462         }
 463 }
 464
 465 /*
 466  * channel mode setting
 467  */
 468 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 469                             struct snd_ctl_elem_info *uinfo)
 470 {
 471         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 472         struct alc_spec *spec = codec->spec;
 473         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 474                                     spec->num_channel_mode);
 475 }
 476
 477 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 478                            struct snd_ctl_elem_value *ucontrol)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 483                                    spec->num_channel_mode,
 484                                    spec->ext_channel_count);
 485 }
 486
 487 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 488                            struct snd_ctl_elem_value *ucontrol)
 489 {
 490         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 491         struct alc_spec *spec = codec->spec;
 492         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 493                                       spec->num_channel_mode,
 494                                       &spec->ext_channel_count);
 495         if (err >= 0 && !spec->const_channel_count) {
 496                 spec->multiout.max_channels = spec->ext_channel_count;
 497                 if (spec->need_dac_fix)
 498                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 499         }
 500         return err;
 501 }
 502
 503 /*
 504  * Control the mode of pin widget settings via the mixer.  "pc" is used
 505  * instead of "%" to avoid consequences of accidently treating the % as
 506  * being part of a format specifier.  Maximum allowed length of a value is
 507  * 63 characters plus NULL terminator.
 508  *
 509  * Note: some retasking pin complexes seem to ignore requests for input
 510  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 511  * are requested.  Therefore order this list so that this behaviour will not
 512  * cause problems when mixer clients move through the enum sequentially.
 513  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 514  * March 2006.
 515  */
 516 static char *alc_pin_mode_names[] = {
 517         "Mic 50pc bias", "Mic 80pc bias",
 518         "Line in", "Line out", "Headphone out",
 519 };
 520 static unsigned char alc_pin_mode_values[] = {
 521         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 522 };
 523 /* The control can present all 5 options, or it can limit the options based
 524  * in the pin being assumed to be exclusively an input or an output pin.  In
 525  * addition, "input" pins may or may not process the mic bias option
 526  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 527  * accept requests for bias as of chip versions up to March 2006) and/or
 528  * wiring in the computer.
 529  */
 530 #define ALC_PIN_DIR_IN              0x00
 531 #define ALC_PIN_DIR_OUT             0x01
 532 #define ALC_PIN_DIR_INOUT           0x02
 533 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 534 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 535
 536 /* Info about the pin modes supported by the different pin direction modes.
 537  * For each direction the minimum and maximum values are given.
 538  */
 539 static signed char alc_pin_mode_dir_info[5][2] = {
 540         { 0, 2 },    /* ALC_PIN_DIR_IN */
 541         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 542         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 543         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 544         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 545 };
 546 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 547 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 548 #define alc_pin_mode_n_items(_dir) \
 549         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 550
 551 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 552                              struct snd_ctl_elem_info *uinfo)
 553 {
 554         unsigned int item_num = uinfo->value.enumerated.item;
 555         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 556
 557         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 558         uinfo->count = 1;
 559         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 560
 561         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 562                 item_num = alc_pin_mode_min(dir);
 563         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 564         return 0;
 565 }
 566
 567 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 568                             struct snd_ctl_elem_value *ucontrol)
 569 {
 570         unsigned int i;
 571         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 572         hda_nid_t nid = kcontrol->private_value & 0xffff;
 573         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 574         long *valp = ucontrol->value.integer.value;
 575         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 576                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 577                                                  0x00);
 578
 579         /* Find enumerated value for current pinctl setting */
 580         i = alc_pin_mode_min(dir);
 581         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 582                 i++;
 583         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 584         return 0;
 585 }
 586
 587 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 588                             struct snd_ctl_elem_value *ucontrol)
 589 {
 590         signed int change;
 591         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 592         hda_nid_t nid = kcontrol->private_value & 0xffff;
 593         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 594         long val = *ucontrol->value.integer.value;
 595         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 596                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 597                                                  0x00);
 598
 599         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 600                 val = alc_pin_mode_min(dir);
 601
 602         change = pinctl != alc_pin_mode_values[val];
 603         if (change) {
 604                 /* Set pin mode to that requested */
 605                 snd_hda_codec_write_cache(codec, nid, 0,
 606                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 607                                           alc_pin_mode_values[val]);
 608
 609                 /* Also enable the retasking pin's input/output as required
 610                  * for the requested pin mode.  Enum values of 2 or less are
 611                  * input modes.
 612                  *
 613                  * Dynamically switching the input/output buffers probably
 614                  * reduces noise slightly (particularly on input) so we'll
 615                  * do it.  However, having both input and output buffers
 616                  * enabled simultaneously doesn't seem to be problematic if
 617                  * this turns out to be necessary in the future.
 618                  */
 619                 if (val <= 2) {
 620                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 621                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 622                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 623                                                  HDA_AMP_MUTE, 0);
 624                 } else {
 625                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 626                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 627                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 628                                                  HDA_AMP_MUTE, 0);
 629                 }
 630         }
 631         return change;
 632 }
 633
 634 #define ALC_PIN_MODE(xname, nid, dir) \
 635         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 636           .info = alc_pin_mode_info, \
 637           .get = alc_pin_mode_get, \
 638           .put = alc_pin_mode_put, \
 639           .private_value = nid | (dir<<16) }
 640
 641 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 642  * together using a mask with more than one bit set.  This control is
 643  * currently used only by the ALC260 test model.  At this stage they are not
 644  * needed for any "production" models.
 645  */
 646 #ifdef CONFIG_SND_DEBUG
 647 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 648
 649 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 650                              struct snd_ctl_elem_value *ucontrol)
 651 {
 652         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 653         hda_nid_t nid = kcontrol->private_value & 0xffff;
 654         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 655         long *valp = ucontrol->value.integer.value;
 656         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 657                                               AC_VERB_GET_GPIO_DATA, 0x00);
 658
 659         *valp = (val & mask) != 0;
 660         return 0;
 661 }
 662 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 663                              struct snd_ctl_elem_value *ucontrol)
 664 {
 665         signed int change;
 666         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 667         hda_nid_t nid = kcontrol->private_value & 0xffff;
 668         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 669         long val = *ucontrol->value.integer.value;
 670         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 671                                                     AC_VERB_GET_GPIO_DATA,
 672                                                     0x00);
 673
 674         /* Set/unset the masked GPIO bit(s) as needed */
 675         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 676         if (val == 0)
 677                 gpio_data &= ~mask;
 678         else
 679                 gpio_data |= mask;
 680         snd_hda_codec_write_cache(codec, nid, 0,
 681                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 682
 683         return change;
 684 }
 685 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 686         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 687           .info = alc_gpio_data_info, \
 688           .get = alc_gpio_data_get, \
 689           .put = alc_gpio_data_put, \
 690           .private_value = nid | (mask<<16) }
 691 #endif   /* CONFIG_SND_DEBUG */
 692
 693 /* A switch control to allow the enabling of the digital IO pins on the
 694  * ALC260.  This is incredibly simplistic; the intention of this control is
 695  * to provide something in the test model allowing digital outputs to be
 696  * identified if present.  If models are found which can utilise these
 697  * outputs a more complete mixer control can be devised for those models if
 698  * necessary.
 699  */
 700 #ifdef CONFIG_SND_DEBUG
 701 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 702
 703 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 704                               struct snd_ctl_elem_value *ucontrol)
 705 {
 706         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 707         hda_nid_t nid = kcontrol->private_value & 0xffff;
 708         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 709         long *valp = ucontrol->value.integer.value;
 710         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 711                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 712
 713         *valp = (val & mask) != 0;
 714         return 0;
 715 }
 716 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 717                               struct snd_ctl_elem_value *ucontrol)
 718 {
 719         signed int change;
 720         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 721         hda_nid_t nid = kcontrol->private_value & 0xffff;
 722         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 723         long val = *ucontrol->value.integer.value;
 724         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 725                                                     AC_VERB_GET_DIGI_CONVERT_1,
 726                                                     0x00);
 727
 728         /* Set/unset the masked control bit(s) as needed */
 729         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 730         if (val==0)
 731                 ctrl_data &= ~mask;
 732         else
 733                 ctrl_data |= mask;
 734         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 735                                   ctrl_data);
 736
 737         return change;
 738 }
 739 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 740         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 741           .info = alc_spdif_ctrl_info, \
 742           .get = alc_spdif_ctrl_get, \
 743           .put = alc_spdif_ctrl_put, \
 744           .private_value = nid | (mask<<16) }
 745 #endif   /* CONFIG_SND_DEBUG */
 746
 747 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 748  * Again, this is only used in the ALC26x test models to help identify when
 749  * the EAPD line must be asserted for features to work.
 750  */
 751 #ifdef CONFIG_SND_DEBUG
 752 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 753
 754 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 755                               struct snd_ctl_elem_value *ucontrol)
 756 {
 757         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 758         hda_nid_t nid = kcontrol->private_value & 0xffff;
 759         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 760         long *valp = ucontrol->value.integer.value;
 761         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 762                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 763
 764         *valp = (val & mask) != 0;
 765         return 0;
 766 }
 767
 768 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 769                               struct snd_ctl_elem_value *ucontrol)
 770 {
 771         int change;
 772         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 773         hda_nid_t nid = kcontrol->private_value & 0xffff;
 774         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 775         long val = *ucontrol->value.integer.value;
 776         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 777                                                     AC_VERB_GET_EAPD_BTLENABLE,
 778                                                     0x00);
 779
 780         /* Set/unset the masked control bit(s) as needed */
 781         change = (!val ? 0 : mask) != (ctrl_data & mask);
 782         if (!val)
 783                 ctrl_data &= ~mask;
 784         else
 785                 ctrl_data |= mask;
 786         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 787                                   ctrl_data);
 788
 789         return change;
 790 }
 791
 792 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 793         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 794           .info = alc_eapd_ctrl_info, \
 795           .get = alc_eapd_ctrl_get, \
 796           .put = alc_eapd_ctrl_put, \
 797           .private_value = nid | (mask<<16) }
 798 #endif   /* CONFIG_SND_DEBUG */
 799
 800 /*
 801  * set up the input pin config (depending on the given auto-pin type)
 802  */
 803 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 804                               int auto_pin_type)
 805 {
 806         unsigned int val = PIN_IN;
 807
 808         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 809                 unsigned int pincap;
 810                 pincap = snd_hda_query_pin_caps(codec, nid);
 811                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 812                 if (pincap & AC_PINCAP_VREF_80)
 813                         val = PIN_VREF80;
 814                 else if (pincap & AC_PINCAP_VREF_50)
 815                         val = PIN_VREF50;
 816                 else if (pincap & AC_PINCAP_VREF_100)
 817                         val = PIN_VREF100;
 818                 else if (pincap & AC_PINCAP_VREF_GRD)
 819                         val = PIN_VREFGRD;
 820         }
 821         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 822 }
 823
 824 /*
 825  */
 826 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 827 {
 828         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 829                 return;
 830         spec->mixers[spec->num_mixers++] = mix;
 831 }
 832
 833 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 834 {
 835         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 836                 return;
 837         spec->init_verbs[spec->num_init_verbs++] = verb;
 838 }
 839
 840 #ifdef CONFIG_PROC_FS
 841 /*
 842  * hook for proc
 843  */
 844 static void print_realtek_coef(struct snd_info_buffer *buffer,
 845                                struct hda_codec *codec, hda_nid_t nid)
 846 {
 847         int coeff;
 848
 849         if (nid != 0x20)
 850                 return;
 851         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 852         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 853         coeff = snd_hda_codec_read(codec, nid, 0,
 854                                    AC_VERB_GET_COEF_INDEX, 0);
 855         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 856 }
 857 #else
 858 #define print_realtek_coef      NULL
 859 #endif
 860
 861 /*
 862  * set up from the preset table
 863  */
 864 static void setup_preset(struct hda_codec *codec,
 865                          const struct alc_config_preset *preset)
 866 {
 867         struct alc_spec *spec = codec->spec;
 868         int i;
 869
 870         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 871                 add_mixer(spec, preset->mixers[i]);
 872         spec->cap_mixer = preset->cap_mixer;
 873         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 874              i++)
 875                 add_verb(spec, preset->init_verbs[i]);
 876
 877         spec->channel_mode = preset->channel_mode;
 878         spec->num_channel_mode = preset->num_channel_mode;
 879         spec->need_dac_fix = preset->need_dac_fix;
 880         spec->const_channel_count = preset->const_channel_count;
 881
 882         if (preset->const_channel_count)
 883                 spec->multiout.max_channels = preset->const_channel_count;
 884         else
 885                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 886         spec->ext_channel_count = spec->channel_mode[0].channels;
 887
 888         spec->multiout.num_dacs = preset->num_dacs;
 889         spec->multiout.dac_nids = preset->dac_nids;
 890         spec->multiout.dig_out_nid = preset->dig_out_nid;
 891         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 892         spec->multiout.hp_nid = preset->hp_nid;
 893
 894         spec->num_mux_defs = preset->num_mux_defs;
 895         if (!spec->num_mux_defs)
 896                 spec->num_mux_defs = 1;
 897         spec->input_mux = preset->input_mux;
 898
 899         spec->num_adc_nids = preset->num_adc_nids;
 900         spec->adc_nids = preset->adc_nids;
 901         spec->capsrc_nids = preset->capsrc_nids;
 902         spec->dig_in_nid = preset->dig_in_nid;
 903
 904         spec->unsol_event = preset->unsol_event;
 905         spec->init_hook = preset->init_hook;
 906 #ifdef CONFIG_SND_HDA_POWER_SAVE
 907         spec->power_hook = preset->power_hook;
 908         spec->loopback.amplist = preset->loopbacks;
 909 #endif
 910
 911         if (preset->setup)
 912                 preset->setup(codec);
 913 }
 914
 915 /* Enable GPIO mask and set output */
 916 static struct hda_verb alc_gpio1_init_verbs[] = {
 917         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 918         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 919         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 920         { }
 921 };
 922
 923 static struct hda_verb alc_gpio2_init_verbs[] = {
 924         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 925         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 926         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 927         { }
 928 };
 929
 930 static struct hda_verb alc_gpio3_init_verbs[] = {
 931         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 932         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 933         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 934         { }
 935 };
 936
 937 /*
 938  * Fix hardware PLL issue
 939  * On some codecs, the analog PLL gating control must be off while
 940  * the default value is 1.
 941  */
 942 static void alc_fix_pll(struct hda_codec *codec)
 943 {
 944         struct alc_spec *spec = codec->spec;
 945         unsigned int val;
 946
 947         if (!spec->pll_nid)
 948                 return;
 949         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 950                             spec->pll_coef_idx);
 951         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 952                                  AC_VERB_GET_PROC_COEF, 0);
 953         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 954                             spec->pll_coef_idx);
 955         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 956                             val & ~(1 << spec->pll_coef_bit));
 957 }
 958
 959 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 960                              unsigned int coef_idx, unsigned int coef_bit)
 961 {
 962         struct alc_spec *spec = codec->spec;
 963         spec->pll_nid = nid;
 964         spec->pll_coef_idx = coef_idx;
 965         spec->pll_coef_bit = coef_bit;
 966         alc_fix_pll(codec);
 967 }
 968
 969 static void alc_automute_pin(struct hda_codec *codec)
 970 {
 971         struct alc_spec *spec = codec->spec;
 972         unsigned int nid = spec->autocfg.hp_pins[0];
 973         int i;
 974
 975         if (!nid)
 976                 return;
 977         spec->jack_present = snd_hda_jack_detect(codec, nid);
 978         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 979                 nid = spec->autocfg.speaker_pins[i];
 980                 if (!nid)
 981                         break;
 982                 snd_hda_codec_write(codec, nid, 0,
 983                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 984                                     spec->jack_present ? 0 : PIN_OUT);
 985         }
 986 }
 987
 988 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 989                                 hda_nid_t nid)
 990 {
 991         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 992         int i, nums;
 993
 994         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 995         for (i = 0; i < nums; i++)
 996                 if (conn[i] == nid)
 997                         return i;
 998         return -1;
 999 }
1000
1001 static void alc_mic_automute(struct hda_codec *codec)
1002 {
1003         struct alc_spec *spec = codec->spec;
1004         struct alc_mic_route *dead, *alive;
1005         unsigned int present, type;
1006         hda_nid_t cap_nid;
1007
1008         if (!spec->auto_mic)
1009                 return;
1010         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1011                 return;
1012         if (snd_BUG_ON(!spec->adc_nids))
1013                 return;
1014
1015         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1016
1017         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1018         if (present) {
1019                 alive = &spec->ext_mic;
1020                 dead = &spec->int_mic;
1021         } else {
1022                 alive = &spec->int_mic;
1023                 dead = &spec->ext_mic;
1024         }
1025
1026         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1027         if (type == AC_WID_AUD_MIX) {
1028                 /* Matrix-mixer style (e.g. ALC882) */
1029                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1030                                          alive->mux_idx,
1031                                          HDA_AMP_MUTE, 0);
1032                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1033                                          dead->mux_idx,
1034                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1035         } else {
1036                 /* MUX style (e.g. ALC880) */
1037                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1038                                           AC_VERB_SET_CONNECT_SEL,
1039                                           alive->mux_idx);
1040         }
1041
1042         /* FIXME: analog mixer */
1043 }
1044
1045 /* unsolicited event for HP jack sensing */
1046 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1047 {
1048         if (codec->vendor_id == 0x10ec0880)
1049                 res >>= 28;
1050         else
1051                 res >>= 26;
1052         switch (res) {
1053         case ALC880_HP_EVENT:
1054                 alc_automute_pin(codec);
1055                 break;
1056         case ALC880_MIC_EVENT:
1057                 alc_mic_automute(codec);
1058                 break;
1059         }
1060 }
1061
1062 static void alc_inithook(struct hda_codec *codec)
1063 {
1064         alc_automute_pin(codec);
1065         alc_mic_automute(codec);
1066 }
1067
1068 /* additional initialization for ALC888 variants */
1069 static void alc888_coef_init(struct hda_codec *codec)
1070 {
1071         unsigned int tmp;
1072
1073         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1074         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1075         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1076         if ((tmp & 0xf0) == 0x20)
1077                 /* alc888S-VC */
1078                 snd_hda_codec_read(codec, 0x20, 0,
1079                                    AC_VERB_SET_PROC_COEF, 0x830);
1080          else
1081                  /* alc888-VB */
1082                  snd_hda_codec_read(codec, 0x20, 0,
1083                                     AC_VERB_SET_PROC_COEF, 0x3030);
1084 }
1085
1086 static void alc889_coef_init(struct hda_codec *codec)
1087 {
1088         unsigned int tmp;
1089
1090         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1091         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1092         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1093         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1094 }
1095
1096 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1097 {
1098         unsigned int tmp;
1099
1100         switch (type) {
1101         case ALC_INIT_GPIO1:
1102                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1103                 break;
1104         case ALC_INIT_GPIO2:
1105                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1106                 break;
1107         case ALC_INIT_GPIO3:
1108                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1109                 break;
1110         case ALC_INIT_DEFAULT:
1111                 switch (codec->vendor_id) {
1112                 case 0x10ec0260:
1113                         snd_hda_codec_write(codec, 0x0f, 0,
1114                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1115                         snd_hda_codec_write(codec, 0x10, 0,
1116                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1117                         break;
1118                 case 0x10ec0262:
1119                 case 0x10ec0267:
1120                 case 0x10ec0268:
1121                 case 0x10ec0269:
1122                 case 0x10ec0272:
1123                 case 0x10ec0660:
1124                 case 0x10ec0662:
1125                 case 0x10ec0663:
1126                 case 0x10ec0862:
1127                 case 0x10ec0889:
1128                         snd_hda_codec_write(codec, 0x14, 0,
1129                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1130                         snd_hda_codec_write(codec, 0x15, 0,
1131                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1132                         break;
1133                 }
1134                 switch (codec->vendor_id) {
1135                 case 0x10ec0260:
1136                         snd_hda_codec_write(codec, 0x1a, 0,
1137                                             AC_VERB_SET_COEF_INDEX, 7);
1138                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1139                                                  AC_VERB_GET_PROC_COEF, 0);
1140                         snd_hda_codec_write(codec, 0x1a, 0,
1141                                             AC_VERB_SET_COEF_INDEX, 7);
1142                         snd_hda_codec_write(codec, 0x1a, 0,
1143                                             AC_VERB_SET_PROC_COEF,
1144                                             tmp | 0x2010);
1145                         break;
1146                 case 0x10ec0262:
1147                 case 0x10ec0880:
1148                 case 0x10ec0882:
1149                 case 0x10ec0883:
1150                 case 0x10ec0885:
1151                 case 0x10ec0887:
1152                 case 0x10ec0889:
1153                         alc889_coef_init(codec);
1154                         break;
1155                 case 0x10ec0888:
1156                         alc888_coef_init(codec);
1157                         break;
1158                 case 0x10ec0267:
1159                 case 0x10ec0268:
1160                         snd_hda_codec_write(codec, 0x20, 0,
1161                                             AC_VERB_SET_COEF_INDEX, 7);
1162                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1163                                                  AC_VERB_GET_PROC_COEF, 0);
1164                         snd_hda_codec_write(codec, 0x20, 0,
1165                                             AC_VERB_SET_COEF_INDEX, 7);
1166                         snd_hda_codec_write(codec, 0x20, 0,
1167                                             AC_VERB_SET_PROC_COEF,
1168                                             tmp | 0x3000);
1169                         break;
1170                 }
1171                 break;
1172         }
1173 }
1174
1175 static void alc_init_auto_hp(struct hda_codec *codec)
1176 {
1177         struct alc_spec *spec = codec->spec;
1178
1179         if (!spec->autocfg.hp_pins[0])
1180                 return;
1181
1182         if (!spec->autocfg.speaker_pins[0]) {
1183                 if (spec->autocfg.line_out_pins[0] &&
1184                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1185                         spec->autocfg.speaker_pins[0] =
1186                                 spec->autocfg.line_out_pins[0];
1187                 else
1188                         return;
1189         }
1190
1191         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1192                     spec->autocfg.hp_pins[0]);
1193         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1194                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1195                                   AC_USRSP_EN | ALC880_HP_EVENT);
1196         spec->unsol_event = alc_sku_unsol_event;
1197 }
1198
1199 static void alc_init_auto_mic(struct hda_codec *codec)
1200 {
1201         struct alc_spec *spec = codec->spec;
1202         struct auto_pin_cfg *cfg = &spec->autocfg;
1203         hda_nid_t fixed, ext;
1204         int i;
1205
1206         /* there must be only two mic inputs exclusively */
1207         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1208                 if (cfg->input_pins[i])
1209                         return;
1210
1211         fixed = ext = 0;
1212         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1213                 hda_nid_t nid = cfg->input_pins[i];
1214                 unsigned int defcfg;
1215                 if (!nid)
1216                         return;
1217                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1218                 switch (get_defcfg_connect(defcfg)) {
1219                 case AC_JACK_PORT_FIXED:
1220                         if (fixed)
1221                                 return; /* already occupied */
1222                         fixed = nid;
1223                         break;
1224                 case AC_JACK_PORT_COMPLEX:
1225                         if (ext)
1226                                 return; /* already occupied */
1227                         ext = nid;
1228                         break;
1229                 default:
1230                         return; /* invalid entry */
1231                 }
1232         }
1233         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1234                 return; /* no unsol support */
1235         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1236                     ext, fixed);
1237         spec->ext_mic.pin = ext;
1238         spec->int_mic.pin = fixed;
1239         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1240         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1241         spec->auto_mic = 1;
1242         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1243                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1244                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1245         spec->unsol_event = alc_sku_unsol_event;
1246 }
1247
1248 /* check subsystem ID and set up device-specific initialization;
1249  * return 1 if initialized, 0 if invalid SSID
1250  */
1251 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1252  *      31 ~ 16 :       Manufacture ID
1253  *      15 ~ 8  :       SKU ID
1254  *      7  ~ 0  :       Assembly ID
1255  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1256  */
1257 static int alc_subsystem_id(struct hda_codec *codec,
1258                             hda_nid_t porta, hda_nid_t porte,
1259                             hda_nid_t portd)
1260 {
1261         unsigned int ass, tmp, i;
1262         unsigned nid;
1263         struct alc_spec *spec = codec->spec;
1264
1265         ass = codec->subsystem_id & 0xffff;
1266         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1267                 goto do_sku;
1268
1269         /* invalid SSID, check the special NID pin defcfg instead */
1270         /*
1271          * 31~30        : port connectivity
1272          * 29~21        : reserve
1273          * 20           : PCBEEP input
1274          * 19~16        : Check sum (15:1)
1275          * 15~1         : Custom
1276          * 0            : override
1277         */
1278         nid = 0x1d;
1279         if (codec->vendor_id == 0x10ec0260)
1280                 nid = 0x17;
1281         ass = snd_hda_codec_get_pincfg(codec, nid);
1282         snd_printd("realtek: No valid SSID, "
1283                    "checking pincfg 0x%08x for NID 0x%x\n",
1284                    ass, nid);
1285         if (!(ass & 1) && !(ass & 0x100000))
1286                 return 0;
1287         if ((ass >> 30) != 1)   /* no physical connection */
1288                 return 0;
1289
1290         /* check sum */
1291         tmp = 0;
1292         for (i = 1; i < 16; i++) {
1293                 if ((ass >> i) & 1)
1294                         tmp++;
1295         }
1296         if (((ass >> 16) & 0xf) != tmp)
1297                 return 0;
1298 do_sku:
1299         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1300                    ass & 0xffff, codec->vendor_id);
1301         /*
1302          * 0 : override
1303          * 1 :  Swap Jack
1304          * 2 : 0 --> Desktop, 1 --> Laptop
1305          * 3~5 : External Amplifier control
1306          * 7~6 : Reserved
1307         */
1308         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1309         switch (tmp) {
1310         case 1:
1311                 spec->init_amp = ALC_INIT_GPIO1;
1312                 break;
1313         case 3:
1314                 spec->init_amp = ALC_INIT_GPIO2;
1315                 break;
1316         case 7:
1317                 spec->init_amp = ALC_INIT_GPIO3;
1318                 break;
1319         case 5:
1320                 spec->init_amp = ALC_INIT_DEFAULT;
1321                 break;
1322         }
1323
1324         /* is laptop or Desktop and enable the function "Mute internal speaker
1325          * when the external headphone out jack is plugged"
1326          */
1327         if (!(ass & 0x8000))
1328                 return 1;
1329         /*
1330          * 10~8 : Jack location
1331          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1332          * 14~13: Resvered
1333          * 15   : 1 --> enable the function "Mute internal speaker
1334          *              when the external headphone out jack is plugged"
1335          */
1336         if (!spec->autocfg.hp_pins[0]) {
1337                 hda_nid_t nid;
1338                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1339                 if (tmp == 0)
1340                         nid = porta;
1341                 else if (tmp == 1)
1342                         nid = porte;
1343                 else if (tmp == 2)
1344                         nid = portd;
1345                 else
1346                         return 1;
1347                 for (i = 0; i < spec->autocfg.line_outs; i++)
1348                         if (spec->autocfg.line_out_pins[i] == nid)
1349                                 return 1;
1350                 spec->autocfg.hp_pins[0] = nid;
1351         }
1352
1353         alc_init_auto_hp(codec);
1354         alc_init_auto_mic(codec);
1355         return 1;
1356 }
1357
1358 static void alc_ssid_check(struct hda_codec *codec,
1359                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1360 {
1361         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1362                 struct alc_spec *spec = codec->spec;
1363                 snd_printd("realtek: "
1364                            "Enable default setup for auto mode as fallback\n");
1365                 spec->init_amp = ALC_INIT_DEFAULT;
1366                 alc_init_auto_hp(codec);
1367                 alc_init_auto_mic(codec);
1368         }
1369 }
1370
1371 /*
1372  * Fix-up pin default configurations and add default verbs
1373  */
1374
1375 struct alc_pincfg {
1376         hda_nid_t nid;
1377         u32 val;
1378 };
1379
1380 struct alc_fixup {
1381         const struct alc_pincfg *pins;
1382         const struct hda_verb *verbs;
1383 };
1384
1385 static void alc_pick_fixup(struct hda_codec *codec,
1386                            const struct snd_pci_quirk *quirk,
1387                            const struct alc_fixup *fix)
1388 {
1389         const struct alc_pincfg *cfg;
1390
1391         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1392         if (!quirk)
1393                 return;
1394
1395         fix += quirk->value;
1396         cfg = fix->pins;
1397         if (cfg) {
1398                 for (; cfg->nid; cfg++)
1399                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1400         }
1401         if (fix->verbs)
1402                 add_verb(codec->spec, fix->verbs);
1403 }
1404
1405 static int alc_read_coef_idx(struct hda_codec *codec,
1406                         unsigned int coef_idx)
1407 {
1408         unsigned int val;
1409         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1410                                 coef_idx);
1411         val = snd_hda_codec_read(codec, 0x20, 0,
1412                                 AC_VERB_GET_PROC_COEF, 0);
1413         return val;
1414 }
1415
1416 /*
1417  * ALC888
1418  */
1419
1420 /*
1421  * 2ch mode
1422  */
1423 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1424 /* Mic-in jack as mic in */
1425         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1426         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1427 /* Line-in jack as Line in */
1428         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1429         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1430 /* Line-Out as Front */
1431         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1432         { } /* end */
1433 };
1434
1435 /*
1436  * 4ch mode
1437  */
1438 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1439 /* Mic-in jack as mic in */
1440         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1441         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1442 /* Line-in jack as Surround */
1443         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1444         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1445 /* Line-Out as Front */
1446         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1447         { } /* end */
1448 };
1449
1450 /*
1451  * 6ch mode
1452  */
1453 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1454 /* Mic-in jack as CLFE */
1455         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1456         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1457 /* Line-in jack as Surround */
1458         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1459         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1460 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1461         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1462         { } /* end */
1463 };
1464
1465 /*
1466  * 8ch mode
1467  */
1468 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1469 /* Mic-in jack as CLFE */
1470         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1471         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1472 /* Line-in jack as Surround */
1473         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1474         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1475 /* Line-Out as Side */
1476         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1477         { } /* end */
1478 };
1479
1480 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1481         { 2, alc888_4ST_ch2_intel_init },
1482         { 4, alc888_4ST_ch4_intel_init },
1483         { 6, alc888_4ST_ch6_intel_init },
1484         { 8, alc888_4ST_ch8_intel_init },
1485 };
1486
1487 /*
1488  * ALC888 Fujitsu Siemens Amillo xa3530
1489  */
1490
1491 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1492 /* Front Mic: set to PIN_IN (empty by default) */
1493         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1494 /* Connect Internal HP to Front */
1495         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1496         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1497         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1498 /* Connect Bass HP to Front */
1499         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1500         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1501         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1502 /* Connect Line-Out side jack (SPDIF) to Side */
1503         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1504         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1505         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1506 /* Connect Mic jack to CLFE */
1507         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1508         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1509         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1510 /* Connect Line-in jack to Surround */
1511         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1512         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1513         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1514 /* Connect HP out jack to Front */
1515         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1516         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1517         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1518 /* Enable unsolicited event for HP jack and Line-out jack */
1519         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1520         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1521         {}
1522 };
1523
1524 static void alc_automute_amp(struct hda_codec *codec)
1525 {
1526         struct alc_spec *spec = codec->spec;
1527         unsigned int mute;
1528         hda_nid_t nid;
1529         int i;
1530
1531         spec->jack_present = 0;
1532         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1533                 nid = spec->autocfg.hp_pins[i];
1534                 if (!nid)
1535                         break;
1536                 if (snd_hda_jack_detect(codec, nid)) {
1537                         spec->jack_present = 1;
1538                         break;
1539                 }
1540         }
1541
1542         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1543         /* Toggle internal speakers muting */
1544         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1545                 nid = spec->autocfg.speaker_pins[i];
1546                 if (!nid)
1547                         break;
1548                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1549                                          HDA_AMP_MUTE, mute);
1550         }
1551 }
1552
1553 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1554                                          unsigned int res)
1555 {
1556         if (codec->vendor_id == 0x10ec0880)
1557                 res >>= 28;
1558         else
1559                 res >>= 26;
1560         if (res == ALC880_HP_EVENT)
1561                 alc_automute_amp(codec);
1562 }
1563
1564 static void alc889_automute_setup(struct hda_codec *codec)
1565 {
1566         struct alc_spec *spec = codec->spec;
1567
1568         spec->autocfg.hp_pins[0] = 0x15;
1569         spec->autocfg.speaker_pins[0] = 0x14;
1570         spec->autocfg.speaker_pins[1] = 0x16;
1571         spec->autocfg.speaker_pins[2] = 0x17;
1572         spec->autocfg.speaker_pins[3] = 0x19;
1573         spec->autocfg.speaker_pins[4] = 0x1a;
1574 }
1575
1576 static void alc889_intel_init_hook(struct hda_codec *codec)
1577 {
1578         alc889_coef_init(codec);
1579         alc_automute_amp(codec);
1580 }
1581
1582 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1583 {
1584         struct alc_spec *spec = codec->spec;
1585
1586         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1587         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1588         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1589         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1590 }
1591
1592 /*
1593  * ALC888 Acer Aspire 4930G model
1594  */
1595
1596 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1597 /* Front Mic: set to PIN_IN (empty by default) */
1598         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1599 /* Unselect Front Mic by default in input mixer 3 */
1600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1601 /* Enable unsolicited event for HP jack */
1602         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1603 /* Connect Internal HP to front */
1604         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1605         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1606         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1607 /* Connect HP out to front */
1608         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1609         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1610         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1611         { }
1612 };
1613
1614 /*
1615  * ALC888 Acer Aspire 6530G model
1616  */
1617
1618 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1619 /* Bias voltage on for external mic port */
1620         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1621 /* Front Mic: set to PIN_IN (empty by default) */
1622         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1623 /* Unselect Front Mic by default in input mixer 3 */
1624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1625 /* Enable unsolicited event for HP jack */
1626         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1627 /* Enable speaker output */
1628         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1629         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1630 /* Enable headphone output */
1631         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1632         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1633         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1634         { }
1635 };
1636
1637 /*
1638  * ALC889 Acer Aspire 8930G model
1639  */
1640
1641 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1642 /* Front Mic: set to PIN_IN (empty by default) */
1643         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1644 /* Unselect Front Mic by default in input mixer 3 */
1645         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1646 /* Enable unsolicited event for HP jack */
1647         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1648 /* Connect Internal Front to Front */
1649         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1650         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1651         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1652 /* Connect Internal Rear to Rear */
1653         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1654         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1655         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1656 /* Connect Internal CLFE to CLFE */
1657         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1658         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1659         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1660 /* Connect HP out to Front */
1661         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1662         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1663         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1664 /* Enable all DACs */
1665 /*  DAC DISABLE/MUTE 1? */
1666 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1667         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1668         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1669 /*  DAC DISABLE/MUTE 2? */
1670 /*  some bit here disables the other DACs. Init=0x4900 */
1671         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1672         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1673 /* DMIC fix
1674  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1675  * which makes the stereo useless. However, either the mic or the ALC889
1676  * makes the signal become a difference/sum signal instead of standard
1677  * stereo, which is annoying. So instead we flip this bit which makes the
1678  * codec replicate the sum signal to both channels, turning it into a
1679  * normal mono mic.
1680  */
1681 /*  DMIC_CONTROL? Init value = 0x0001 */
1682         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1683         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1684         { }
1685 };
1686
1687 static struct hda_input_mux alc888_2_capture_sources[2] = {
1688         /* Front mic only available on one ADC */
1689         {
1690                 .num_items = 4,
1691                 .items = {
1692                         { "Mic", 0x0 },
1693                         { "Line", 0x2 },
1694                         { "CD", 0x4 },
1695                         { "Front Mic", 0xb },
1696                 },
1697         },
1698         {
1699                 .num_items = 3,
1700                 .items = {
1701                         { "Mic", 0x0 },
1702                         { "Line", 0x2 },
1703                         { "CD", 0x4 },
1704                 },
1705         }
1706 };
1707
1708 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1709         /* Interal mic only available on one ADC */
1710         {
1711                 .num_items = 5,
1712                 .items = {
1713                         { "Ext Mic", 0x0 },
1714                         { "Line In", 0x2 },
1715                         { "CD", 0x4 },
1716                         { "Input Mix", 0xa },
1717                         { "Int Mic", 0xb },
1718                 },
1719         },
1720         {
1721                 .num_items = 4,
1722                 .items = {
1723                         { "Ext Mic", 0x0 },
1724                         { "Line In", 0x2 },
1725                         { "CD", 0x4 },
1726                         { "Input Mix", 0xa },
1727                 },
1728         }
1729 };
1730
1731 static struct hda_input_mux alc889_capture_sources[3] = {
1732         /* Digital mic only available on first "ADC" */
1733         {
1734                 .num_items = 5,
1735                 .items = {
1736                         { "Mic", 0x0 },
1737                         { "Line", 0x2 },
1738                         { "CD", 0x4 },
1739                         { "Front Mic", 0xb },
1740                         { "Input Mix", 0xa },
1741                 },
1742         },
1743         {
1744                 .num_items = 4,
1745                 .items = {
1746                         { "Mic", 0x0 },
1747                         { "Line", 0x2 },
1748                         { "CD", 0x4 },
1749                         { "Input Mix", 0xa },
1750                 },
1751         },
1752         {
1753                 .num_items = 4,
1754                 .items = {
1755                         { "Mic", 0x0 },
1756                         { "Line", 0x2 },
1757                         { "CD", 0x4 },
1758                         { "Input Mix", 0xa },
1759                 },
1760         }
1761 };
1762
1763 static struct snd_kcontrol_new alc888_base_mixer[] = {
1764         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1765         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1766         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1767         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1768         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1769                 HDA_OUTPUT),
1770         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1771         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1772         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1773         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1774         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1775         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1776         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1777         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1778         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1779         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1780         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1781         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1782         { } /* end */
1783 };
1784
1785 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1786         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1787         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1788         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1789         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1790         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1791                 HDA_OUTPUT),
1792         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1793         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1794         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1795         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1796         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1797         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1798         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1799         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1800         { } /* end */
1801 };
1802
1803
1804 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1805 {
1806         struct alc_spec *spec = codec->spec;
1807
1808         spec->autocfg.hp_pins[0] = 0x15;
1809         spec->autocfg.speaker_pins[0] = 0x14;
1810         spec->autocfg.speaker_pins[1] = 0x16;
1811         spec->autocfg.speaker_pins[2] = 0x17;
1812 }
1813
1814 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1815 {
1816         struct alc_spec *spec = codec->spec;
1817
1818         spec->autocfg.hp_pins[0] = 0x15;
1819         spec->autocfg.speaker_pins[0] = 0x14;
1820         spec->autocfg.speaker_pins[1] = 0x16;
1821         spec->autocfg.speaker_pins[2] = 0x17;
1822 }
1823
1824 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1825 {
1826         struct alc_spec *spec = codec->spec;
1827
1828         spec->autocfg.hp_pins[0] = 0x15;
1829         spec->autocfg.speaker_pins[0] = 0x14;
1830         spec->autocfg.speaker_pins[1] = 0x16;
1831         spec->autocfg.speaker_pins[2] = 0x1b;
1832 }
1833
1834 #ifdef CONFIG_SND_HDA_POWER_SAVE
1835 static void alc889_power_eapd(struct hda_codec *codec, int power)
1836 {
1837         snd_hda_codec_write(codec, 0x14, 0,
1838                             AC_VERB_SET_EAPD_BTLENABLE, power ? 2 : 0);
1839         snd_hda_codec_write(codec, 0x15, 0,
1840                             AC_VERB_SET_EAPD_BTLENABLE, power ? 2 : 0);
1841 }
1842 #endif
1843
1844 /*
1845  * ALC880 3-stack model
1846  *
1847  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1848  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1849  *                 F-Mic = 0x1b, HP = 0x19
1850  */
1851
1852 static hda_nid_t alc880_dac_nids[4] = {
1853         /* front, rear, clfe, rear_surr */
1854         0x02, 0x05, 0x04, 0x03
1855 };
1856
1857 static hda_nid_t alc880_adc_nids[3] = {
1858         /* ADC0-2 */
1859         0x07, 0x08, 0x09,
1860 };
1861
1862 /* The datasheet says the node 0x07 is connected from inputs,
1863  * but it shows zero connection in the real implementation on some devices.
1864  * Note: this is a 915GAV bug, fixed on 915GLV
1865  */
1866 static hda_nid_t alc880_adc_nids_alt[2] = {
1867         /* ADC1-2 */
1868         0x08, 0x09,
1869 };
1870
1871 #define ALC880_DIGOUT_NID       0x06
1872 #define ALC880_DIGIN_NID        0x0a
1873
1874 static struct hda_input_mux alc880_capture_source = {
1875         .num_items = 4,
1876         .items = {
1877                 { "Mic", 0x0 },
1878                 { "Front Mic", 0x3 },
1879                 { "Line", 0x2 },
1880                 { "CD", 0x4 },
1881         },
1882 };
1883
1884 /* channel source setting (2/6 channel selection for 3-stack) */
1885 /* 2ch mode */
1886 static struct hda_verb alc880_threestack_ch2_init[] = {
1887         /* set line-in to input, mute it */
1888         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1889         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1890         /* set mic-in to input vref 80%, mute it */
1891         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1892         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1893         { } /* end */
1894 };
1895
1896 /* 6ch mode */
1897 static struct hda_verb alc880_threestack_ch6_init[] = {
1898         /* set line-in to output, unmute it */
1899         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1900         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1901         /* set mic-in to output, unmute it */
1902         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1903         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1904         { } /* end */
1905 };
1906
1907 static struct hda_channel_mode alc880_threestack_modes[2] = {
1908         { 2, alc880_threestack_ch2_init },
1909         { 6, alc880_threestack_ch6_init },
1910 };
1911
1912 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1913         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1914         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1915         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1916         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1917         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1918         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1920         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1921         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1922         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1923         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1924         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1926         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1927         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1928         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1929         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1930         {
1931                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1932                 .name = "Channel Mode",
1933                 .info = alc_ch_mode_info,
1934                 .get = alc_ch_mode_get,
1935                 .put = alc_ch_mode_put,
1936         },
1937         { } /* end */
1938 };
1939
1940 /* capture mixer elements */
1941 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1942                             struct snd_ctl_elem_info *uinfo)
1943 {
1944         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1945         struct alc_spec *spec = codec->spec;
1946         int err;
1947
1948         mutex_lock(&codec->control_mutex);
1949         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1950                                                       HDA_INPUT);
1951         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1952         mutex_unlock(&codec->control_mutex);
1953         return err;
1954 }
1955
1956 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1957                            unsigned int size, unsigned int __user *tlv)
1958 {
1959         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1960         struct alc_spec *spec = codec->spec;
1961         int err;
1962
1963         mutex_lock(&codec->control_mutex);
1964         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1965                                                       HDA_INPUT);
1966         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1967         mutex_unlock(&codec->control_mutex);
1968         return err;
1969 }
1970
1971 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1972                              struct snd_ctl_elem_value *ucontrol);
1973
1974 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1975                                  struct snd_ctl_elem_value *ucontrol,
1976                                  getput_call_t func)
1977 {
1978         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1979         struct alc_spec *spec = codec->spec;
1980         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1981         int err;
1982
1983         mutex_lock(&codec->control_mutex);
1984         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1985                                                       3, 0, HDA_INPUT);
1986         err = func(kcontrol, ucontrol);
1987         mutex_unlock(&codec->control_mutex);
1988         return err;
1989 }
1990
1991 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1992                            struct snd_ctl_elem_value *ucontrol)
1993 {
1994         return alc_cap_getput_caller(kcontrol, ucontrol,
1995                                      snd_hda_mixer_amp_volume_get);
1996 }
1997
1998 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1999                            struct snd_ctl_elem_value *ucontrol)
2000 {
2001         return alc_cap_getput_caller(kcontrol, ucontrol,
2002                                      snd_hda_mixer_amp_volume_put);
2003 }
2004
2005 /* capture mixer elements */
2006 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2007
2008 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2009                           struct snd_ctl_elem_value *ucontrol)
2010 {
2011         return alc_cap_getput_caller(kcontrol, ucontrol,
2012                                      snd_hda_mixer_amp_switch_get);
2013 }
2014
2015 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2016                           struct snd_ctl_elem_value *ucontrol)
2017 {
2018         return alc_cap_getput_caller(kcontrol, ucontrol,
2019                                      snd_hda_mixer_amp_switch_put);
2020 }
2021
2022 #define _DEFINE_CAPMIX(num) \
2023         { \
2024                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2025                 .name = "Capture Switch", \
2026                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2027                 .count = num, \
2028                 .info = alc_cap_sw_info, \
2029                 .get = alc_cap_sw_get, \
2030                 .put = alc_cap_sw_put, \
2031         }, \
2032         { \
2033                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2034                 .name = "Capture Volume", \
2035                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2036                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2037                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2038                 .count = num, \
2039                 .info = alc_cap_vol_info, \
2040                 .get = alc_cap_vol_get, \
2041                 .put = alc_cap_vol_put, \
2042                 .tlv = { .c = alc_cap_vol_tlv }, \
2043         }
2044
2045 #define _DEFINE_CAPSRC(num) \
2046         { \
2047                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2048                 /* .name = "Capture Source", */ \
2049                 .name = "Input Source", \
2050                 .count = num, \
2051                 .info = alc_mux_enum_info, \
2052                 .get = alc_mux_enum_get, \
2053                 .put = alc_mux_enum_put, \
2054         }
2055
2056 #define DEFINE_CAPMIX(num) \
2057 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2058         _DEFINE_CAPMIX(num),                                  \
2059         _DEFINE_CAPSRC(num),                                  \
2060         { } /* end */                                         \
2061 }
2062
2063 #define DEFINE_CAPMIX_NOSRC(num) \
2064 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2065         _DEFINE_CAPMIX(num),                                        \
2066         { } /* end */                                               \
2067 }
2068
2069 /* up to three ADCs */
2070 DEFINE_CAPMIX(1);
2071 DEFINE_CAPMIX(2);
2072 DEFINE_CAPMIX(3);
2073 DEFINE_CAPMIX_NOSRC(1);
2074 DEFINE_CAPMIX_NOSRC(2);
2075 DEFINE_CAPMIX_NOSRC(3);
2076
2077 /*
2078  * ALC880 5-stack model
2079  *
2080  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2081  *      Side = 0x02 (0xd)
2082  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2083  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2084  */
2085
2086 /* additional mixers to alc880_three_stack_mixer */
2087 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2088         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2089         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2090         { } /* end */
2091 };
2092
2093 /* channel source setting (6/8 channel selection for 5-stack) */
2094 /* 6ch mode */
2095 static struct hda_verb alc880_fivestack_ch6_init[] = {
2096         /* set line-in to input, mute it */
2097         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2098         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2099         { } /* end */
2100 };
2101
2102 /* 8ch mode */
2103 static struct hda_verb alc880_fivestack_ch8_init[] = {
2104         /* set line-in to output, unmute it */
2105         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2106         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2107         { } /* end */
2108 };
2109
2110 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2111         { 6, alc880_fivestack_ch6_init },
2112         { 8, alc880_fivestack_ch8_init },
2113 };
2114
2115
2116 /*
2117  * ALC880 6-stack model
2118  *
2119  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2120  *      Side = 0x05 (0x0f)
2121  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2122  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2123  */
2124
2125 static hda_nid_t alc880_6st_dac_nids[4] = {
2126         /* front, rear, clfe, rear_surr */
2127         0x02, 0x03, 0x04, 0x05
2128 };
2129
2130 static struct hda_input_mux alc880_6stack_capture_source = {
2131         .num_items = 4,
2132         .items = {
2133                 { "Mic", 0x0 },
2134                 { "Front Mic", 0x1 },
2135                 { "Line", 0x2 },
2136                 { "CD", 0x4 },
2137         },
2138 };
2139
2140 /* fixed 8-channels */
2141 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2142         { 8, NULL },
2143 };
2144
2145 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2146         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2147         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2148         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2149         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2150         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2151         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2152         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2153         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2154         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2155         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2156         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2157         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2158         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2159         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2160         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2161         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2162         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2163         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2164         {
2165                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2166                 .name = "Channel Mode",
2167                 .info = alc_ch_mode_info,
2168                 .get = alc_ch_mode_get,
2169                 .put = alc_ch_mode_put,
2170         },
2171         { } /* end */
2172 };
2173
2174
2175 /*
2176  * ALC880 W810 model
2177  *
2178  * W810 has rear IO for:
2179  * Front (DAC 02)
2180  * Surround (DAC 03)
2181  * Center/LFE (DAC 04)
2182  * Digital out (06)
2183  *
2184  * The system also has a pair of internal speakers, and a headphone jack.
2185  * These are both connected to Line2 on the codec, hence to DAC 02.
2186  *
2187  * There is a variable resistor to control the speaker or headphone
2188  * volume. This is a hardware-only device without a software API.
2189  *
2190  * Plugging headphones in will disable the internal speakers. This is
2191  * implemented in hardware, not via the driver using jack sense. In
2192  * a similar fashion, plugging into the rear socket marked "front" will
2193  * disable both the speakers and headphones.
2194  *
2195  * For input, there's a microphone jack, and an "audio in" jack.
2196  * These may not do anything useful with this driver yet, because I
2197  * haven't setup any initialization verbs for these yet...
2198  */
2199
2200 static hda_nid_t alc880_w810_dac_nids[3] = {
2201         /* front, rear/surround, clfe */
2202         0x02, 0x03, 0x04
2203 };
2204
2205 /* fixed 6 channels */
2206 static struct hda_channel_mode alc880_w810_modes[1] = {
2207         { 6, NULL }
2208 };
2209
2210 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2211 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2212         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2213         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2214         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2215         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2216         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2217         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2218         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2219         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2221         { } /* end */
2222 };
2223
2224
2225 /*
2226  * Z710V model
2227  *
2228  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2229  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2230  *                 Line = 0x1a
2231  */
2232
2233 static hda_nid_t alc880_z71v_dac_nids[1] = {
2234         0x02
2235 };
2236 #define ALC880_Z71V_HP_DAC      0x03
2237
2238 /* fixed 2 channels */
2239 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2240         { 2, NULL }
2241 };
2242
2243 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2244         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2245         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2246         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2247         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2248         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2249         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2250         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2251         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2252         { } /* end */
2253 };
2254
2255
2256 /*
2257  * ALC880 F1734 model
2258  *
2259  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2260  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2261  */
2262
2263 static hda_nid_t alc880_f1734_dac_nids[1] = {
2264         0x03
2265 };
2266 #define ALC880_F1734_HP_DAC     0x02
2267
2268 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2269         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2270         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2271         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2272         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2273         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2274         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2275         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2276         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2277         { } /* end */
2278 };
2279
2280 static struct hda_input_mux alc880_f1734_capture_source = {
2281         .num_items = 2,
2282         .items = {
2283                 { "Mic", 0x1 },
2284                 { "CD", 0x4 },
2285         },
2286 };
2287
2288
2289 /*
2290  * ALC880 ASUS model
2291  *
2292  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2293  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2294  *  Mic = 0x18, Line = 0x1a
2295  */
2296
2297 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2298 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2299
2300 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2301         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2302         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2303         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2304         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2305         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2306         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2307         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2308         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2309         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2310         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2311         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2312         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2313         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2314         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2315         {
2316                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2317                 .name = "Channel Mode",
2318                 .info = alc_ch_mode_info,
2319                 .get = alc_ch_mode_get,
2320                 .put = alc_ch_mode_put,
2321         },
2322         { } /* end */
2323 };
2324
2325 /*
2326  * ALC880 ASUS W1V model
2327  *
2328  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2329  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2330  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2331  */
2332
2333 /* additional mixers to alc880_asus_mixer */
2334 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2335         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2336         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2337         { } /* end */
2338 };
2339
2340 /* TCL S700 */
2341 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2342         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2343         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2344         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2345         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2346         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2347         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2348         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2349         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2350         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2351         { } /* end */
2352 };
2353
2354 /* Uniwill */
2355 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2356         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2357         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2358         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2359         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2360         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2361         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2362         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2363         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2364         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2365         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2366         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2367         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2368         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2369         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2371         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2372         {
2373                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2374                 .name = "Channel Mode",
2375                 .info = alc_ch_mode_info,
2376                 .get = alc_ch_mode_get,
2377                 .put = alc_ch_mode_put,
2378         },
2379         { } /* end */
2380 };
2381
2382 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2383         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2384         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2385         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2386         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2387         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2388         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2389         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2390         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2391         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2392         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2393         { } /* end */
2394 };
2395
2396 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2397         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2398         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2399         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2400         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2401         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2402         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2403         { } /* end */
2404 };
2405
2406 /*
2407  * virtual master controls
2408  */
2409
2410 /*
2411  * slave controls for virtual master
2412  */
2413 static const char *alc_slave_vols[] = {
2414         "Front Playback Volume",
2415         "Surround Playback Volume",
2416         "Center Playback Volume",
2417         "LFE Playback Volume",
2418         "Side Playback Volume",
2419         "Headphone Playback Volume",
2420         "Speaker Playback Volume",
2421         "Mono Playback Volume",
2422         "Line-Out Playback Volume",
2423         "PCM Playback Volume",
2424         NULL,
2425 };
2426
2427 static const char *alc_slave_sws[] = {
2428         "Front Playback Switch",
2429         "Surround Playback Switch",
2430         "Center Playback Switch",
2431         "LFE Playback Switch",
2432         "Side Playback Switch",
2433         "Headphone Playback Switch",
2434         "Speaker Playback Switch",
2435         "Mono Playback Switch",
2436         "IEC958 Playback Switch",
2437         "Line-Out Playback Switch",
2438         "PCM Playback Switch",
2439         NULL,
2440 };
2441
2442 /*
2443  * build control elements
2444  */
2445
2446 static void alc_free_kctls(struct hda_codec *codec);
2447
2448 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2449 /* additional beep mixers; the actual parameters are overwritten at build */
2450 static struct snd_kcontrol_new alc_beep_mixer[] = {
2451         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2452         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2453         { } /* end */
2454 };
2455 #endif
2456
2457 static int alc_build_controls(struct hda_codec *codec)
2458 {
2459         struct alc_spec *spec = codec->spec;
2460         int err;
2461         int i;
2462
2463         for (i = 0; i < spec->num_mixers; i++) {
2464                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2465                 if (err < 0)
2466                         return err;
2467         }
2468         if (spec->cap_mixer) {
2469                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2470                 if (err < 0)
2471                         return err;
2472         }
2473         if (spec->multiout.dig_out_nid) {
2474                 err = snd_hda_create_spdif_out_ctls(codec,
2475                                                     spec->multiout.dig_out_nid);
2476                 if (err < 0)
2477                         return err;
2478                 if (!spec->no_analog) {
2479                         err = snd_hda_create_spdif_share_sw(codec,
2480                                                             &spec->multiout);
2481                         if (err < 0)
2482                                 return err;
2483                         spec->multiout.share_spdif = 1;
2484                 }
2485         }
2486         if (spec->dig_in_nid) {
2487                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2488                 if (err < 0)
2489                         return err;
2490         }
2491
2492 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2493         /* create beep controls if needed */
2494         if (spec->beep_amp) {
2495                 struct snd_kcontrol_new *knew;
2496                 for (knew = alc_beep_mixer; knew->name; knew++) {
2497                         struct snd_kcontrol *kctl;
2498                         kctl = snd_ctl_new1(knew, codec);
2499                         if (!kctl)
2500                                 return -ENOMEM;
2501                         kctl->private_value = spec->beep_amp;
2502                         err = snd_hda_ctl_add(codec,
2503                                         get_amp_nid_(spec->beep_amp), kctl);
2504                         if (err < 0)
2505                                 return err;
2506                 }
2507         }
2508 #endif
2509
2510         /* if we have no master control, let's create it */
2511         if (!spec->no_analog &&
2512             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2513                 unsigned int vmaster_tlv[4];
2514                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2515                                         HDA_OUTPUT, vmaster_tlv);
2516                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2517                                           vmaster_tlv, alc_slave_vols);
2518                 if (err < 0)
2519                         return err;
2520         }
2521         if (!spec->no_analog &&
2522             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2523                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2524                                           NULL, alc_slave_sws);
2525                 if (err < 0)
2526                         return err;
2527         }
2528
2529         alc_free_kctls(codec); /* no longer needed */
2530         return 0;
2531 }
2532
2533
2534 /*
2535  * initialize the codec volumes, etc
2536  */
2537
2538 /*
2539  * generic initialization of ADC, input mixers and output mixers
2540  */
2541 static struct hda_verb alc880_volume_init_verbs[] = {
2542         /*
2543          * Unmute ADC0-2 and set the default input to mic-in
2544          */
2545         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2547         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2548         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2549         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2550         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2551
2552         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2553          * mixer widget
2554          * Note: PASD motherboards uses the Line In 2 as the input for front
2555          * panel mic (mic 2)
2556          */
2557         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2558         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2559         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2560         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2561         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2562         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2563         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2564         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2565
2566         /*
2567          * Set up output mixers (0x0c - 0x0f)
2568          */
2569         /* set vol=0 to output mixers */
2570         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2571         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2572         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2573         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2574         /* set up input amps for analog loopback */
2575         /* Amp Indices: DAC = 0, mixer = 1 */
2576         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2577         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2578         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2579         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2580         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2581         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2582         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2583         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2584
2585         { }
2586 };
2587
2588 /*
2589  * 3-stack pin configuration:
2590  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2591  */
2592 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2593         /*
2594          * preset connection lists of input pins
2595          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2596          */
2597         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2598         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2599         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2600
2601         /*
2602          * Set pin mode and muting
2603          */
2604         /* set front pin widgets 0x14 for output */
2605         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2606         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2608         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2609         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2610         /* Mic2 (as headphone out) for HP output */
2611         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2612         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2613         /* Line In pin widget for input */
2614         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2615         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2616         /* Line2 (as front mic) pin widget for input and vref at 80% */
2617         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2618         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2619         /* CD pin widget for input */
2620         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2621
2622         { }
2623 };
2624
2625 /*
2626  * 5-stack pin configuration:
2627  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2628  * line-in/side = 0x1a, f-mic = 0x1b
2629  */
2630 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2631         /*
2632          * preset connection lists of input pins
2633          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2634          */
2635         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2636         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2637
2638         /*
2639          * Set pin mode and muting
2640          */
2641         /* set pin widgets 0x14-0x17 for output */
2642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2643         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2644         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2645         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2646         /* unmute pins for output (no gain on this amp) */
2647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2648         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2649         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2650         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2651
2652         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2653         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2654         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2655         /* Mic2 (as headphone out) for HP output */
2656         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2657         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2658         /* Line In pin widget for input */
2659         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2660         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2661         /* Line2 (as front mic) pin widget for input and vref at 80% */
2662         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2663         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2664         /* CD pin widget for input */
2665         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2666
2667         { }
2668 };
2669
2670 /*
2671  * W810 pin configuration:
2672  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2673  */
2674 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2675         /* hphone/speaker input selector: front DAC */
2676         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2677
2678         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2679         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2680         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2681         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2682         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2683         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2684
2685         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2686         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2687
2688         { }
2689 };
2690
2691 /*
2692  * Z71V pin configuration:
2693  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2694  */
2695 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2696         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2697         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2698         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2699         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2700
2701         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2702         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2703         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2704         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2705
2706         { }
2707 };
2708
2709 /*
2710  * 6-stack pin configuration:
2711  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2712  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2713  */
2714 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2715         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2716
2717         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2718         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2719         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2720         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2721         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2722         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2723         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2724         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2725
2726         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2727         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2728         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2729         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2730         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2731         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2732         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2733         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2735
2736         { }
2737 };
2738
2739 /*
2740  * Uniwill pin configuration:
2741  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2742  * line = 0x1a
2743  */
2744 static struct hda_verb alc880_uniwill_init_verbs[] = {
2745         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2746
2747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2748         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2749         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2750         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2751         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2752         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2753         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2754         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2755         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2756         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2757         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2758         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2759         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2760         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2761
2762         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2763         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2764         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2765         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2767         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2768         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2769         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2770         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2771
2772         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2773         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2774
2775         { }
2776 };
2777
2778 /*
2779 * Uniwill P53
2780 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2781  */
2782 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2783         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2784
2785         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2786         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2787         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2788         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2789         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2790         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2791         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2792         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2793         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2794         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2795         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2796         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2797
2798         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2799         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2800         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2801         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2802         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2803         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2804
2805         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2806         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2807
2808         { }
2809 };
2810
2811 static struct hda_verb alc880_beep_init_verbs[] = {
2812         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2813         { }
2814 };
2815
2816 /* auto-toggle front mic */
2817 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2818 {
2819         unsigned int present;
2820         unsigned char bits;
2821
2822         present = snd_hda_jack_detect(codec, 0x18);
2823         bits = present ? HDA_AMP_MUTE : 0;
2824         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2825 }
2826
2827 static void alc880_uniwill_setup(struct hda_codec *codec)
2828 {
2829         struct alc_spec *spec = codec->spec;
2830
2831         spec->autocfg.hp_pins[0] = 0x14;
2832         spec->autocfg.speaker_pins[0] = 0x15;
2833         spec->autocfg.speaker_pins[0] = 0x16;
2834 }
2835
2836 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2837 {
2838         alc_automute_amp(codec);
2839         alc880_uniwill_mic_automute(codec);
2840 }
2841
2842 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2843                                        unsigned int res)
2844 {
2845         /* Looks like the unsol event is incompatible with the standard
2846          * definition.  4bit tag is placed at 28 bit!
2847          */
2848         switch (res >> 28) {
2849         case ALC880_MIC_EVENT:
2850                 alc880_uniwill_mic_automute(codec);
2851                 break;
2852         default:
2853                 alc_automute_amp_unsol_event(codec, res);
2854                 break;
2855         }
2856 }
2857
2858 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2859 {
2860         struct alc_spec *spec = codec->spec;
2861
2862         spec->autocfg.hp_pins[0] = 0x14;
2863         spec->autocfg.speaker_pins[0] = 0x15;
2864 }
2865
2866 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2867 {
2868         unsigned int present;
2869
2870         present = snd_hda_codec_read(codec, 0x21, 0,
2871                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2872         present &= HDA_AMP_VOLMASK;
2873         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2874                                  HDA_AMP_VOLMASK, present);
2875         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2876                                  HDA_AMP_VOLMASK, present);
2877 }
2878
2879 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2880                                            unsigned int res)
2881 {
2882         /* Looks like the unsol event is incompatible with the standard
2883          * definition.  4bit tag is placed at 28 bit!
2884          */
2885         if ((res >> 28) == ALC880_DCVOL_EVENT)
2886                 alc880_uniwill_p53_dcvol_automute(codec);
2887         else
2888                 alc_automute_amp_unsol_event(codec, res);
2889 }
2890
2891 /*
2892  * F1734 pin configuration:
2893  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2894  */
2895 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2896         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2897         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2898         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2899         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2900         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2901
2902         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2903         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2904         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2905         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2906
2907         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2908         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2909         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2910         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2911         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2912         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2913         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2914         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2915         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2916
2917         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2918         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2919
2920         { }
2921 };
2922
2923 /*
2924  * ASUS pin configuration:
2925  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2926  */
2927 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2928         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2929         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2930         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2931         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2932
2933         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2934         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2935         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2936         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2937         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2938         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2939         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2940         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2941
2942         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2943         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2944         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2945         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2946         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2947         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2948         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2949         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2950         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2951
2952         { }
2953 };
2954
2955 /* Enable GPIO mask and set output */
2956 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2957 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2958 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2959
2960 /* Clevo m520g init */
2961 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2962         /* headphone output */
2963         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2964         /* line-out */
2965         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2966         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2967         /* Line-in */
2968         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2969         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2970         /* CD */
2971         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2972         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2973         /* Mic1 (rear panel) */
2974         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2975         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2976         /* Mic2 (front panel) */
2977         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2978         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2979         /* headphone */
2980         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2981         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2982         /* change to EAPD mode */
2983         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2984         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2985
2986         { }
2987 };
2988
2989 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2990         /* change to EAPD mode */
2991         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2992         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2993
2994         /* Headphone output */
2995         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2996         /* Front output*/
2997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2998         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2999
3000         /* Line In pin widget for input */
3001         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3002         /* CD pin widget for input */
3003         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3004         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3005         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3006
3007         /* change to EAPD mode */
3008         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3009         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3010
3011         { }
3012 };
3013
3014 /*
3015  * LG m1 express dual
3016  *
3017  * Pin assignment:
3018  *   Rear Line-In/Out (blue): 0x14
3019  *   Build-in Mic-In: 0x15
3020  *   Speaker-out: 0x17
3021  *   HP-Out (green): 0x1b
3022  *   Mic-In/Out (red): 0x19
3023  *   SPDIF-Out: 0x1e
3024  */
3025
3026 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3027 static hda_nid_t alc880_lg_dac_nids[3] = {
3028         0x05, 0x02, 0x03
3029 };
3030
3031 /* seems analog CD is not working */
3032 static struct hda_input_mux alc880_lg_capture_source = {
3033         .num_items = 3,
3034         .items = {
3035                 { "Mic", 0x1 },
3036                 { "Line", 0x5 },
3037                 { "Internal Mic", 0x6 },
3038         },
3039 };
3040
3041 /* 2,4,6 channel modes */
3042 static struct hda_verb alc880_lg_ch2_init[] = {
3043         /* set line-in and mic-in to input */
3044         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3045         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3046         { }
3047 };
3048
3049 static struct hda_verb alc880_lg_ch4_init[] = {
3050         /* set line-in to out and mic-in to input */
3051         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3052         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3053         { }
3054 };
3055
3056 static struct hda_verb alc880_lg_ch6_init[] = {
3057         /* set line-in and mic-in to output */
3058         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3059         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3060         { }
3061 };
3062
3063 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3064         { 2, alc880_lg_ch2_init },
3065         { 4, alc880_lg_ch4_init },
3066         { 6, alc880_lg_ch6_init },
3067 };
3068
3069 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3070         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3071         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3072         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3073         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3074         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3075         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3076         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3077         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3078         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3079         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3080         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3081         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3082         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3083         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3084         {
3085                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3086                 .name = "Channel Mode",
3087                 .info = alc_ch_mode_info,
3088                 .get = alc_ch_mode_get,
3089                 .put = alc_ch_mode_put,
3090         },
3091         { } /* end */
3092 };
3093
3094 static struct hda_verb alc880_lg_init_verbs[] = {
3095         /* set capture source to mic-in */
3096         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3097         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3098         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3099         /* mute all amp mixer inputs */
3100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3102         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3103         /* line-in to input */
3104         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3105         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3106         /* built-in mic */
3107         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3108         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3109         /* speaker-out */
3110         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3111         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3112         /* mic-in to input */
3113         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3114         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3115         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3116         /* HP-out */
3117         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3118         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3119         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3120         /* jack sense */
3121         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3122         { }
3123 };
3124
3125 /* toggle speaker-output according to the hp-jack state */
3126 static void alc880_lg_setup(struct hda_codec *codec)
3127 {
3128         struct alc_spec *spec = codec->spec;
3129
3130         spec->autocfg.hp_pins[0] = 0x1b;
3131         spec->autocfg.speaker_pins[0] = 0x17;
3132 }
3133
3134 /*
3135  * LG LW20
3136  *
3137  * Pin assignment:
3138  *   Speaker-out: 0x14
3139  *   Mic-In: 0x18
3140  *   Built-in Mic-In: 0x19
3141  *   Line-In: 0x1b
3142  *   HP-Out: 0x1a
3143  *   SPDIF-Out: 0x1e
3144  */
3145
3146 static struct hda_input_mux alc880_lg_lw_capture_source = {
3147         .num_items = 3,
3148         .items = {
3149                 { "Mic", 0x0 },
3150                 { "Internal Mic", 0x1 },
3151                 { "Line In", 0x2 },
3152         },
3153 };
3154
3155 #define alc880_lg_lw_modes alc880_threestack_modes
3156
3157 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3158         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3159         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3160         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3161         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3162         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3163         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3164         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3165         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3166         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3167         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3168         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3169         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3170         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3171         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3172         {
3173                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3174                 .name = "Channel Mode",
3175                 .info = alc_ch_mode_info,
3176                 .get = alc_ch_mode_get,
3177                 .put = alc_ch_mode_put,
3178         },
3179         { } /* end */
3180 };
3181
3182 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3183         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3184         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3185         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3186
3187         /* set capture source to mic-in */
3188         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3189         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3190         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3191         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3192         /* speaker-out */
3193         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3194         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3195         /* HP-out */
3196         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3197         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3198         /* mic-in to input */
3199         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3200         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3201         /* built-in mic */
3202         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3203         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3204         /* jack sense */
3205         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3206         { }
3207 };
3208
3209 /* toggle speaker-output according to the hp-jack state */
3210 static void alc880_lg_lw_setup(struct hda_codec *codec)
3211 {
3212         struct alc_spec *spec = codec->spec;
3213
3214         spec->autocfg.hp_pins[0] = 0x1b;
3215         spec->autocfg.speaker_pins[0] = 0x14;
3216 }
3217
3218 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3219         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3220         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3223         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3224         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3225         { } /* end */
3226 };
3227
3228 static struct hda_input_mux alc880_medion_rim_capture_source = {
3229         .num_items = 2,
3230         .items = {
3231                 { "Mic", 0x0 },
3232                 { "Internal Mic", 0x1 },
3233         },
3234 };
3235
3236 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3237         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3238
3239         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3240         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3241
3242         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3243         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3244         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3245         /* Mic2 (as headphone out) for HP output */
3246         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3247         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3248         /* Internal Speaker */
3249         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3250         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3251
3252         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3253         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3254
3255         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3256         { }
3257 };
3258
3259 /* toggle speaker-output according to the hp-jack state */
3260 static void alc880_medion_rim_automute(struct hda_codec *codec)
3261 {
3262         struct alc_spec *spec = codec->spec;
3263         alc_automute_amp(codec);
3264         /* toggle EAPD */
3265         if (spec->jack_present)
3266                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3267         else
3268                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3269 }
3270
3271 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3272                                           unsigned int res)
3273 {
3274         /* Looks like the unsol event is incompatible with the standard
3275          * definition.  4bit tag is placed at 28 bit!
3276          */
3277         if ((res >> 28) == ALC880_HP_EVENT)
3278                 alc880_medion_rim_automute(codec);
3279 }
3280
3281 static void alc880_medion_rim_setup(struct hda_codec *codec)
3282 {
3283         struct alc_spec *spec = codec->spec;
3284
3285         spec->autocfg.hp_pins[0] = 0x14;
3286         spec->autocfg.speaker_pins[0] = 0x1b;
3287 }
3288
3289 #ifdef CONFIG_SND_HDA_POWER_SAVE
3290 static struct hda_amp_list alc880_loopbacks[] = {
3291         { 0x0b, HDA_INPUT, 0 },
3292         { 0x0b, HDA_INPUT, 1 },
3293         { 0x0b, HDA_INPUT, 2 },
3294         { 0x0b, HDA_INPUT, 3 },
3295         { 0x0b, HDA_INPUT, 4 },
3296         { } /* end */
3297 };
3298
3299 static struct hda_amp_list alc880_lg_loopbacks[] = {
3300         { 0x0b, HDA_INPUT, 1 },
3301         { 0x0b, HDA_INPUT, 6 },
3302         { 0x0b, HDA_INPUT, 7 },
3303         { } /* end */
3304 };
3305 #endif
3306
3307 /*
3308  * Common callbacks
3309  */
3310
3311 static int alc_init(struct hda_codec *codec)
3312 {
3313         struct alc_spec *spec = codec->spec;
3314         unsigned int i;
3315
3316         alc_fix_pll(codec);
3317         alc_auto_init_amp(codec, spec->init_amp);
3318
3319         for (i = 0; i < spec->num_init_verbs; i++)
3320                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3321
3322         if (spec->init_hook)
3323                 spec->init_hook(codec);
3324
3325         return 0;
3326 }
3327
3328 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3329 {
3330         struct alc_spec *spec = codec->spec;
3331
3332         if (spec->unsol_event)
3333                 spec->unsol_event(codec, res);
3334 }
3335
3336 #ifdef CONFIG_SND_HDA_POWER_SAVE
3337 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3338 {
3339         struct alc_spec *spec = codec->spec;
3340         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3341 }
3342 #endif
3343
3344 /*
3345  * Analog playback callbacks
3346  */
3347 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3348                                     struct hda_codec *codec,
3349                                     struct snd_pcm_substream *substream)
3350 {
3351         struct alc_spec *spec = codec->spec;
3352         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3353                                              hinfo);
3354 }
3355
3356 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3357                                        struct hda_codec *codec,
3358                                        unsigned int stream_tag,
3359                                        unsigned int format,
3360                                        struct snd_pcm_substream *substream)
3361 {
3362         struct alc_spec *spec = codec->spec;
3363         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3364                                                 stream_tag, format, substream);
3365 }
3366
3367 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3368                                        struct hda_codec *codec,
3369                                        struct snd_pcm_substream *substream)
3370 {
3371         struct alc_spec *spec = codec->spec;
3372         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3373 }
3374
3375 /*
3376  * Digital out
3377  */
3378 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3379                                         struct hda_codec *codec,
3380                                         struct snd_pcm_substream *substream)
3381 {
3382         struct alc_spec *spec = codec->spec;
3383         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3384 }
3385
3386 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3387                                            struct hda_codec *codec,
3388                                            unsigned int stream_tag,
3389                                            unsigned int format,
3390                                            struct snd_pcm_substream *substream)
3391 {
3392         struct alc_spec *spec = codec->spec;
3393         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3394                                              stream_tag, format, substream);
3395 }
3396
3397 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3398                                            struct hda_codec *codec,
3399                                            struct snd_pcm_substream *substream)
3400 {
3401         struct alc_spec *spec = codec->spec;
3402         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3403 }
3404
3405 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3406                                          struct hda_codec *codec,
3407                                          struct snd_pcm_substream *substream)
3408 {
3409         struct alc_spec *spec = codec->spec;
3410         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3411 }
3412
3413 /*
3414  * Analog capture
3415  */
3416 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3417                                       struct hda_codec *codec,
3418                                       unsigned int stream_tag,
3419                                       unsigned int format,
3420                                       struct snd_pcm_substream *substream)
3421 {
3422         struct alc_spec *spec = codec->spec;
3423
3424         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3425                                    stream_tag, 0, format);
3426         return 0;
3427 }
3428
3429 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3430                                       struct hda_codec *codec,
3431                                       struct snd_pcm_substream *substream)
3432 {
3433         struct alc_spec *spec = codec->spec;
3434
3435         snd_hda_codec_cleanup_stream(codec,
3436                                      spec->adc_nids[substream->number + 1]);
3437         return 0;
3438 }
3439
3440
3441 /*
3442  */
3443 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3444         .substreams = 1,
3445         .channels_min = 2,
3446         .channels_max = 8,
3447         /* NID is set in alc_build_pcms */
3448         .ops = {
3449                 .open = alc880_playback_pcm_open,
3450                 .prepare = alc880_playback_pcm_prepare,
3451                 .cleanup = alc880_playback_pcm_cleanup
3452         },
3453 };
3454
3455 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3456         .substreams = 1,
3457         .channels_min = 2,
3458         .channels_max = 2,
3459         /* NID is set in alc_build_pcms */
3460 };
3461
3462 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3463         .substreams = 1,
3464         .channels_min = 2,
3465         .channels_max = 2,
3466         /* NID is set in alc_build_pcms */
3467 };
3468
3469 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3470         .substreams = 2, /* can be overridden */
3471         .channels_min = 2,
3472         .channels_max = 2,
3473         /* NID is set in alc_build_pcms */
3474         .ops = {
3475                 .prepare = alc880_alt_capture_pcm_prepare,
3476                 .cleanup = alc880_alt_capture_pcm_cleanup
3477         },
3478 };
3479
3480 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3481         .substreams = 1,
3482         .channels_min = 2,
3483         .channels_max = 2,
3484         /* NID is set in alc_build_pcms */
3485         .ops = {
3486                 .open = alc880_dig_playback_pcm_open,
3487                 .close = alc880_dig_playback_pcm_close,
3488                 .prepare = alc880_dig_playback_pcm_prepare,
3489                 .cleanup = alc880_dig_playback_pcm_cleanup
3490         },
3491 };
3492
3493 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3494         .substreams = 1,
3495         .channels_min = 2,
3496         .channels_max = 2,
3497         /* NID is set in alc_build_pcms */
3498 };
3499
3500 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3501 static struct hda_pcm_stream alc_pcm_null_stream = {
3502         .substreams = 0,
3503         .channels_min = 0,
3504         .channels_max = 0,
3505 };
3506
3507 static int alc_build_pcms(struct hda_codec *codec)
3508 {
3509         struct alc_spec *spec = codec->spec;
3510         struct hda_pcm *info = spec->pcm_rec;
3511         int i;
3512
3513         codec->num_pcms = 1;
3514         codec->pcm_info = info;
3515
3516         if (spec->no_analog)
3517                 goto skip_analog;
3518
3519         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3520                  "%s Analog", codec->chip_name);
3521         info->name = spec->stream_name_analog;
3522
3523         if (spec->stream_analog_playback) {
3524                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3525                         return -EINVAL;
3526                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3527                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3528         }
3529         if (spec->stream_analog_capture) {
3530                 if (snd_BUG_ON(!spec->adc_nids))
3531                         return -EINVAL;
3532                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3533                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3534         }
3535
3536         if (spec->channel_mode) {
3537                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3538                 for (i = 0; i < spec->num_channel_mode; i++) {
3539                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3540                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3541                         }
3542                 }
3543         }
3544
3545  skip_analog:
3546         /* SPDIF for stream index #1 */
3547         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3548                 snprintf(spec->stream_name_digital,
3549                          sizeof(spec->stream_name_digital),
3550                          "%s Digital", codec->chip_name);
3551                 codec->num_pcms = 2;
3552                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3553                 info = spec->pcm_rec + 1;
3554                 info->name = spec->stream_name_digital;
3555                 if (spec->dig_out_type)
3556                         info->pcm_type = spec->dig_out_type;
3557                 else
3558                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3559                 if (spec->multiout.dig_out_nid &&
3560                     spec->stream_digital_playback) {
3561                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3562                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3563                 }
3564                 if (spec->dig_in_nid &&
3565                     spec->stream_digital_capture) {
3566                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3567                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3568                 }
3569                 /* FIXME: do we need this for all Realtek codec models? */
3570                 codec->spdif_status_reset = 1;
3571         }
3572
3573         if (spec->no_analog)
3574                 return 0;
3575
3576         /* If the use of more than one ADC is requested for the current
3577          * model, configure a second analog capture-only PCM.
3578          */
3579         /* Additional Analaog capture for index #2 */
3580         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3581             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3582                 codec->num_pcms = 3;
3583                 info = spec->pcm_rec + 2;
3584                 info->name = spec->stream_name_analog;
3585                 if (spec->alt_dac_nid) {
3586                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3587                                 *spec->stream_analog_alt_playback;
3588                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3589                                 spec->alt_dac_nid;
3590                 } else {
3591                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3592                                 alc_pcm_null_stream;
3593                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3594                 }
3595                 if (spec->num_adc_nids > 1) {
3596                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3597                                 *spec->stream_analog_alt_capture;
3598                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3599                                 spec->adc_nids[1];
3600                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3601                                 spec->num_adc_nids - 1;
3602                 } else {
3603                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3604                                 alc_pcm_null_stream;
3605                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3606                 }
3607         }
3608
3609         return 0;
3610 }
3611
3612 static void alc_free_kctls(struct hda_codec *codec)
3613 {
3614         struct alc_spec *spec = codec->spec;
3615
3616         if (spec->kctls.list) {
3617                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3618                 int i;
3619                 for (i = 0; i < spec->kctls.used; i++)
3620                         kfree(kctl[i].name);
3621         }
3622         snd_array_free(&spec->kctls);
3623 }
3624
3625 static void alc_free(struct hda_codec *codec)
3626 {
3627         struct alc_spec *spec = codec->spec;
3628
3629         if (!spec)
3630                 return;
3631
3632         alc_free_kctls(codec);
3633         kfree(spec);
3634         snd_hda_detach_beep_device(codec);
3635 }
3636
3637 #ifdef CONFIG_SND_HDA_POWER_SAVE
3638 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3639 {
3640         struct alc_spec *spec = codec->spec;
3641         if (spec && spec->power_hook)
3642                 spec->power_hook(codec, 0);
3643         return 0;
3644 }
3645 #endif
3646
3647 #ifdef SND_HDA_NEEDS_RESUME
3648 static int alc_resume(struct hda_codec *codec)
3649 {
3650 #ifdef CONFIG_SND_HDA_POWER_SAVE
3651         struct alc_spec *spec = codec->spec;
3652 #endif
3653         codec->patch_ops.init(codec);
3654         snd_hda_codec_resume_amp(codec);
3655         snd_hda_codec_resume_cache(codec);
3656 #ifdef CONFIG_SND_HDA_POWER_SAVE
3657         if (spec && spec->power_hook)
3658                 spec->power_hook(codec, 1);
3659 #endif
3660         return 0;
3661 }
3662 #endif
3663
3664 /*
3665  */
3666 static struct hda_codec_ops alc_patch_ops = {
3667         .build_controls = alc_build_controls,
3668         .build_pcms = alc_build_pcms,
3669         .init = alc_init,
3670         .free = alc_free,
3671         .unsol_event = alc_unsol_event,
3672 #ifdef SND_HDA_NEEDS_RESUME
3673         .resume = alc_resume,
3674 #endif
3675 #ifdef CONFIG_SND_HDA_POWER_SAVE
3676         .suspend = alc_suspend,
3677         .check_power_status = alc_check_power_status,
3678 #endif
3679 };
3680
3681
3682 /*
3683  * Test configuration for debugging
3684  *
3685  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3686  * enum controls.
3687  */
3688 #ifdef CONFIG_SND_DEBUG
3689 static hda_nid_t alc880_test_dac_nids[4] = {
3690         0x02, 0x03, 0x04, 0x05
3691 };
3692
3693 static struct hda_input_mux alc880_test_capture_source = {
3694         .num_items = 7,
3695         .items = {
3696                 { "In-1", 0x0 },
3697                 { "In-2", 0x1 },
3698                 { "In-3", 0x2 },
3699                 { "In-4", 0x3 },
3700                 { "CD", 0x4 },
3701                 { "Front", 0x5 },
3702                 { "Surround", 0x6 },
3703         },
3704 };
3705
3706 static struct hda_channel_mode alc880_test_modes[4] = {
3707         { 2, NULL },
3708         { 4, NULL },
3709         { 6, NULL },
3710         { 8, NULL },
3711 };
3712
3713 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3714                                  struct snd_ctl_elem_info *uinfo)
3715 {
3716         static char *texts[] = {
3717                 "N/A", "Line Out", "HP Out",
3718                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3719         };
3720         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3721         uinfo->count = 1;
3722         uinfo->value.enumerated.items = 8;
3723         if (uinfo->value.enumerated.item >= 8)
3724                 uinfo->value.enumerated.item = 7;
3725         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3726         return 0;
3727 }
3728
3729 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3730                                 struct snd_ctl_elem_value *ucontrol)
3731 {
3732         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3733         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3734         unsigned int pin_ctl, item = 0;
3735
3736         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3737                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3738         if (pin_ctl & AC_PINCTL_OUT_EN) {
3739                 if (pin_ctl & AC_PINCTL_HP_EN)
3740                         item = 2;
3741                 else
3742                         item = 1;
3743         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3744                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3745                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3746                 case AC_PINCTL_VREF_50:  item = 4; break;
3747                 case AC_PINCTL_VREF_GRD: item = 5; break;
3748                 case AC_PINCTL_VREF_80:  item = 6; break;
3749                 case AC_PINCTL_VREF_100: item = 7; break;
3750                 }
3751         }
3752         ucontrol->value.enumerated.item[0] = item;
3753         return 0;
3754 }
3755
3756 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3757                                 struct snd_ctl_elem_value *ucontrol)
3758 {
3759         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3760         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3761         static unsigned int ctls[] = {
3762                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3763                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3764                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3765                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3766                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3767                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3768         };
3769         unsigned int old_ctl, new_ctl;
3770
3771         old_ctl = snd_hda_codec_read(codec, nid, 0,
3772                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3773         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3774         if (old_ctl != new_ctl) {
3775                 int val;
3776                 snd_hda_codec_write_cache(codec, nid, 0,
3777                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3778                                           new_ctl);
3779                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3780                         HDA_AMP_MUTE : 0;
3781                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3782                                          HDA_AMP_MUTE, val);
3783                 return 1;
3784         }
3785         return 0;
3786 }
3787
3788 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3789                                  struct snd_ctl_elem_info *uinfo)
3790 {
3791         static char *texts[] = {
3792                 "Front", "Surround", "CLFE", "Side"
3793         };
3794         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3795         uinfo->count = 1;
3796         uinfo->value.enumerated.items = 4;
3797         if (uinfo->value.enumerated.item >= 4)
3798                 uinfo->value.enumerated.item = 3;
3799         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3800         return 0;
3801 }
3802
3803 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3804                                 struct snd_ctl_elem_value *ucontrol)
3805 {
3806         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3807         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3808         unsigned int sel;
3809
3810         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3811         ucontrol->value.enumerated.item[0] = sel & 3;
3812         return 0;
3813 }
3814
3815 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3816                                 struct snd_ctl_elem_value *ucontrol)
3817 {
3818         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3819         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3820         unsigned int sel;
3821
3822         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3823         if (ucontrol->value.enumerated.item[0] != sel) {
3824                 sel = ucontrol->value.enumerated.item[0] & 3;
3825                 snd_hda_codec_write_cache(codec, nid, 0,
3826                                           AC_VERB_SET_CONNECT_SEL, sel);
3827                 return 1;
3828         }
3829         return 0;
3830 }
3831
3832 #define PIN_CTL_TEST(xname,nid) {                       \
3833                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3834                         .name = xname,                 \
3835                         .info = alc_test_pin_ctl_info, \
3836                         .get = alc_test_pin_ctl_get,   \
3837                         .put = alc_test_pin_ctl_put,   \
3838                         .private_value = nid           \
3839                         }
3840
3841 #define PIN_SRC_TEST(xname,nid) {                       \
3842                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3843                         .name = xname,                 \
3844                         .info = alc_test_pin_src_info, \
3845                         .get = alc_test_pin_src_get,   \
3846                         .put = alc_test_pin_src_put,   \
3847                         .private_value = nid           \
3848                         }
3849
3850 static struct snd_kcontrol_new alc880_test_mixer[] = {
3851         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3852         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3853         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3854         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3855         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3856         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3857         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3858         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3859         PIN_CTL_TEST("Front Pin Mode", 0x14),
3860         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3861         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3862         PIN_CTL_TEST("Side Pin Mode", 0x17),
3863         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3864         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3865         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3866         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3867         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3868         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3869         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3870         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3871         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3872         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3873         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3874         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3875         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3876         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3877         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3878         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3879         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3880         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3881         {
3882                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3883                 .name = "Channel Mode",
3884                 .info = alc_ch_mode_info,
3885                 .get = alc_ch_mode_get,
3886                 .put = alc_ch_mode_put,
3887         },
3888         { } /* end */
3889 };
3890
3891 static struct hda_verb alc880_test_init_verbs[] = {
3892         /* Unmute inputs of 0x0c - 0x0f */
3893         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3894         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3895         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3896         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3897         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3898         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3899         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3900         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3901         /* Vol output for 0x0c-0x0f */
3902         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3903         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3904         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3905         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3906         /* Set output pins 0x14-0x17 */
3907         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3908         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3909         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3910         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3911         /* Unmute output pins 0x14-0x17 */
3912         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3913         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3914         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3915         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3916         /* Set input pins 0x18-0x1c */
3917         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3918         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3919         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3921         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3922         /* Mute input pins 0x18-0x1b */
3923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3924         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3925         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3926         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3927         /* ADC set up */
3928         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3929         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3930         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3931         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3932         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3933         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3934         /* Analog input/passthru */
3935         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3936         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3937         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3938         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3939         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3940         { }
3941 };
3942 #endif
3943
3944 /*
3945  */
3946
3947 static const char *alc880_models[ALC880_MODEL_LAST] = {
3948         [ALC880_3ST]            = "3stack",
3949         [ALC880_TCL_S700]       = "tcl",
3950         [ALC880_3ST_DIG]        = "3stack-digout",
3951         [ALC880_CLEVO]          = "clevo",
3952         [ALC880_5ST]            = "5stack",
3953         [ALC880_5ST_DIG]        = "5stack-digout",
3954         [ALC880_W810]           = "w810",
3955         [ALC880_Z71V]           = "z71v",
3956         [ALC880_6ST]            = "6stack",
3957         [ALC880_6ST_DIG]        = "6stack-digout",
3958         [ALC880_ASUS]           = "asus",
3959         [ALC880_ASUS_W1V]       = "asus-w1v",
3960         [ALC880_ASUS_DIG]       = "asus-dig",
3961         [ALC880_ASUS_DIG2]      = "asus-dig2",
3962         [ALC880_UNIWILL_DIG]    = "uniwill",
3963         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3964         [ALC880_FUJITSU]        = "fujitsu",
3965         [ALC880_F1734]          = "F1734",
3966         [ALC880_LG]             = "lg",
3967         [ALC880_LG_LW]          = "lg-lw",
3968         [ALC880_MEDION_RIM]     = "medion",
3969 #ifdef CONFIG_SND_DEBUG
3970         [ALC880_TEST]           = "test",
3971 #endif
3972         [ALC880_AUTO]           = "auto",
3973 };
3974
3975 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3976         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3977         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3978         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3979         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3980         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3981         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3982         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3983         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3984         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3985         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3986         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3987         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3988         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3989         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3990         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3991         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3992         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3993         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3994         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3995         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3996         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3997         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3998         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3999         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4000         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4001         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4002         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4003         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4004         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4005         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4006         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4007         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4008         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4009         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4010         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4011         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4012         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4013         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4014         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4015         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4016         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4017         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4018         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4019         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4020         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4021         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4022         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4023         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4024         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4025         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4026         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4027         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4028         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4029         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4030         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4031         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4032         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4033         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4034         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4035         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4036         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4037         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4038         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4039         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4040         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4041         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4042         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4043         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4044         /* default Intel */
4045         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4046         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4047         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4048         {}
4049 };
4050
4051 /*
4052  * ALC880 codec presets
4053  */
4054 static struct alc_config_preset alc880_presets[] = {
4055         [ALC880_3ST] = {
4056                 .mixers = { alc880_three_stack_mixer },
4057                 .init_verbs = { alc880_volume_init_verbs,
4058                                 alc880_pin_3stack_init_verbs },
4059                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4060                 .dac_nids = alc880_dac_nids,
4061                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4062                 .channel_mode = alc880_threestack_modes,
4063                 .need_dac_fix = 1,
4064                 .input_mux = &alc880_capture_source,
4065         },
4066         [ALC880_3ST_DIG] = {
4067                 .mixers = { alc880_three_stack_mixer },
4068                 .init_verbs = { alc880_volume_init_verbs,
4069                                 alc880_pin_3stack_init_verbs },
4070                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4071                 .dac_nids = alc880_dac_nids,
4072                 .dig_out_nid = ALC880_DIGOUT_NID,
4073                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4074                 .channel_mode = alc880_threestack_modes,
4075                 .need_dac_fix = 1,
4076                 .input_mux = &alc880_capture_source,
4077         },
4078         [ALC880_TCL_S700] = {
4079                 .mixers = { alc880_tcl_s700_mixer },
4080                 .init_verbs = { alc880_volume_init_verbs,
4081                                 alc880_pin_tcl_S700_init_verbs,
4082                                 alc880_gpio2_init_verbs },
4083                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4084                 .dac_nids = alc880_dac_nids,
4085                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4086                 .num_adc_nids = 1, /* single ADC */
4087                 .hp_nid = 0x03,
4088                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4089                 .channel_mode = alc880_2_jack_modes,
4090                 .input_mux = &alc880_capture_source,
4091         },
4092         [ALC880_5ST] = {
4093                 .mixers = { alc880_three_stack_mixer,
4094                             alc880_five_stack_mixer},
4095                 .init_verbs = { alc880_volume_init_verbs,
4096                                 alc880_pin_5stack_init_verbs },
4097                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4098                 .dac_nids = alc880_dac_nids,
4099                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4100                 .channel_mode = alc880_fivestack_modes,
4101                 .input_mux = &alc880_capture_source,
4102         },
4103         [ALC880_5ST_DIG] = {
4104                 .mixers = { alc880_three_stack_mixer,
4105                             alc880_five_stack_mixer },
4106                 .init_verbs = { alc880_volume_init_verbs,
4107                                 alc880_pin_5stack_init_verbs },
4108                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4109                 .dac_nids = alc880_dac_nids,
4110                 .dig_out_nid = ALC880_DIGOUT_NID,
4111                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4112                 .channel_mode = alc880_fivestack_modes,
4113                 .input_mux = &alc880_capture_source,
4114         },
4115         [ALC880_6ST] = {
4116                 .mixers = { alc880_six_stack_mixer },
4117                 .init_verbs = { alc880_volume_init_verbs,
4118                                 alc880_pin_6stack_init_verbs },
4119                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4120                 .dac_nids = alc880_6st_dac_nids,
4121                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4122                 .channel_mode = alc880_sixstack_modes,
4123                 .input_mux = &alc880_6stack_capture_source,
4124         },
4125         [ALC880_6ST_DIG] = {
4126                 .mixers = { alc880_six_stack_mixer },
4127                 .init_verbs = { alc880_volume_init_verbs,
4128                                 alc880_pin_6stack_init_verbs },
4129                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4130                 .dac_nids = alc880_6st_dac_nids,
4131                 .dig_out_nid = ALC880_DIGOUT_NID,
4132                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4133                 .channel_mode = alc880_sixstack_modes,
4134                 .input_mux = &alc880_6stack_capture_source,
4135         },
4136         [ALC880_W810] = {
4137                 .mixers = { alc880_w810_base_mixer },
4138                 .init_verbs = { alc880_volume_init_verbs,
4139                                 alc880_pin_w810_init_verbs,
4140                                 alc880_gpio2_init_verbs },
4141                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4142                 .dac_nids = alc880_w810_dac_nids,
4143                 .dig_out_nid = ALC880_DIGOUT_NID,
4144                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4145                 .channel_mode = alc880_w810_modes,
4146                 .input_mux = &alc880_capture_source,
4147         },
4148         [ALC880_Z71V] = {
4149                 .mixers = { alc880_z71v_mixer },
4150                 .init_verbs = { alc880_volume_init_verbs,
4151                                 alc880_pin_z71v_init_verbs },
4152                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4153                 .dac_nids = alc880_z71v_dac_nids,
4154                 .dig_out_nid = ALC880_DIGOUT_NID,
4155                 .hp_nid = 0x03,
4156                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4157                 .channel_mode = alc880_2_jack_modes,
4158                 .input_mux = &alc880_capture_source,
4159         },
4160         [ALC880_F1734] = {
4161                 .mixers = { alc880_f1734_mixer },
4162                 .init_verbs = { alc880_volume_init_verbs,
4163                                 alc880_pin_f1734_init_verbs },
4164                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4165                 .dac_nids = alc880_f1734_dac_nids,
4166                 .hp_nid = 0x02,
4167                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4168                 .channel_mode = alc880_2_jack_modes,
4169                 .input_mux = &alc880_f1734_capture_source,
4170                 .unsol_event = alc880_uniwill_p53_unsol_event,
4171                 .setup = alc880_uniwill_p53_setup,
4172                 .init_hook = alc_automute_amp,
4173         },
4174         [ALC880_ASUS] = {
4175                 .mixers = { alc880_asus_mixer },
4176                 .init_verbs = { alc880_volume_init_verbs,
4177                                 alc880_pin_asus_init_verbs,
4178                                 alc880_gpio1_init_verbs },
4179                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4180                 .dac_nids = alc880_asus_dac_nids,
4181                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4182                 .channel_mode = alc880_asus_modes,
4183                 .need_dac_fix = 1,
4184                 .input_mux = &alc880_capture_source,
4185         },
4186         [ALC880_ASUS_DIG] = {
4187                 .mixers = { alc880_asus_mixer },
4188                 .init_verbs = { alc880_volume_init_verbs,
4189                                 alc880_pin_asus_init_verbs,
4190                                 alc880_gpio1_init_verbs },
4191                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4192                 .dac_nids = alc880_asus_dac_nids,
4193                 .dig_out_nid = ALC880_DIGOUT_NID,
4194                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4195                 .channel_mode = alc880_asus_modes,
4196                 .need_dac_fix = 1,
4197                 .input_mux = &alc880_capture_source,
4198         },
4199         [ALC880_ASUS_DIG2] = {
4200                 .mixers = { alc880_asus_mixer },
4201                 .init_verbs = { alc880_volume_init_verbs,
4202                                 alc880_pin_asus_init_verbs,
4203                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4204                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4205                 .dac_nids = alc880_asus_dac_nids,
4206                 .dig_out_nid = ALC880_DIGOUT_NID,
4207                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4208                 .channel_mode = alc880_asus_modes,
4209                 .need_dac_fix = 1,
4210                 .input_mux = &alc880_capture_source,
4211         },
4212         [ALC880_ASUS_W1V] = {
4213                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4214                 .init_verbs = { alc880_volume_init_verbs,
4215                                 alc880_pin_asus_init_verbs,
4216                                 alc880_gpio1_init_verbs },
4217                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4218                 .dac_nids = alc880_asus_dac_nids,
4219                 .dig_out_nid = ALC880_DIGOUT_NID,
4220                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4221                 .channel_mode = alc880_asus_modes,
4222                 .need_dac_fix = 1,
4223                 .input_mux = &alc880_capture_source,
4224         },
4225         [ALC880_UNIWILL_DIG] = {
4226                 .mixers = { alc880_asus_mixer },
4227                 .init_verbs = { alc880_volume_init_verbs,
4228                                 alc880_pin_asus_init_verbs },
4229                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4230                 .dac_nids = alc880_asus_dac_nids,
4231                 .dig_out_nid = ALC880_DIGOUT_NID,
4232                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4233                 .channel_mode = alc880_asus_modes,
4234                 .need_dac_fix = 1,
4235                 .input_mux = &alc880_capture_source,
4236         },
4237         [ALC880_UNIWILL] = {
4238                 .mixers = { alc880_uniwill_mixer },
4239                 .init_verbs = { alc880_volume_init_verbs,
4240                                 alc880_uniwill_init_verbs },
4241                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4242                 .dac_nids = alc880_asus_dac_nids,
4243                 .dig_out_nid = ALC880_DIGOUT_NID,
4244                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4245                 .channel_mode = alc880_threestack_modes,
4246                 .need_dac_fix = 1,
4247                 .input_mux = &alc880_capture_source,
4248                 .unsol_event = alc880_uniwill_unsol_event,
4249                 .setup = alc880_uniwill_setup,
4250                 .init_hook = alc880_uniwill_init_hook,
4251         },
4252         [ALC880_UNIWILL_P53] = {
4253                 .mixers = { alc880_uniwill_p53_mixer },
4254                 .init_verbs = { alc880_volume_init_verbs,
4255                                 alc880_uniwill_p53_init_verbs },
4256                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4257                 .dac_nids = alc880_asus_dac_nids,
4258                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4259                 .channel_mode = alc880_threestack_modes,
4260                 .input_mux = &alc880_capture_source,
4261                 .unsol_event = alc880_uniwill_p53_unsol_event,
4262                 .setup = alc880_uniwill_p53_setup,
4263                 .init_hook = alc_automute_amp,
4264         },
4265         [ALC880_FUJITSU] = {
4266                 .mixers = { alc880_fujitsu_mixer },
4267                 .init_verbs = { alc880_volume_init_verbs,
4268                                 alc880_uniwill_p53_init_verbs,
4269                                 alc880_beep_init_verbs },
4270                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4271                 .dac_nids = alc880_dac_nids,
4272                 .dig_out_nid = ALC880_DIGOUT_NID,
4273                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4274                 .channel_mode = alc880_2_jack_modes,
4275                 .input_mux = &alc880_capture_source,
4276                 .unsol_event = alc880_uniwill_p53_unsol_event,
4277                 .setup = alc880_uniwill_p53_setup,
4278                 .init_hook = alc_automute_amp,
4279         },
4280         [ALC880_CLEVO] = {
4281                 .mixers = { alc880_three_stack_mixer },
4282                 .init_verbs = { alc880_volume_init_verbs,
4283                                 alc880_pin_clevo_init_verbs },
4284                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4285                 .dac_nids = alc880_dac_nids,
4286                 .hp_nid = 0x03,
4287                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4288                 .channel_mode = alc880_threestack_modes,
4289                 .need_dac_fix = 1,
4290                 .input_mux = &alc880_capture_source,
4291         },
4292         [ALC880_LG] = {
4293                 .mixers = { alc880_lg_mixer },
4294                 .init_verbs = { alc880_volume_init_verbs,
4295                                 alc880_lg_init_verbs },
4296                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4297                 .dac_nids = alc880_lg_dac_nids,
4298                 .dig_out_nid = ALC880_DIGOUT_NID,
4299                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4300                 .channel_mode = alc880_lg_ch_modes,
4301                 .need_dac_fix = 1,
4302                 .input_mux = &alc880_lg_capture_source,
4303                 .unsol_event = alc_automute_amp_unsol_event,
4304                 .setup = alc880_lg_setup,
4305                 .init_hook = alc_automute_amp,
4306 #ifdef CONFIG_SND_HDA_POWER_SAVE
4307                 .loopbacks = alc880_lg_loopbacks,
4308 #endif
4309         },
4310         [ALC880_LG_LW] = {
4311                 .mixers = { alc880_lg_lw_mixer },
4312                 .init_verbs = { alc880_volume_init_verbs,
4313                                 alc880_lg_lw_init_verbs },
4314                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4315                 .dac_nids = alc880_dac_nids,
4316                 .dig_out_nid = ALC880_DIGOUT_NID,
4317                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4318                 .channel_mode = alc880_lg_lw_modes,
4319                 .input_mux = &alc880_lg_lw_capture_source,
4320                 .unsol_event = alc_automute_amp_unsol_event,
4321                 .setup = alc880_lg_lw_setup,
4322                 .init_hook = alc_automute_amp,
4323         },
4324         [ALC880_MEDION_RIM] = {
4325                 .mixers = { alc880_medion_rim_mixer },
4326                 .init_verbs = { alc880_volume_init_verbs,
4327                                 alc880_medion_rim_init_verbs,
4328                                 alc_gpio2_init_verbs },
4329                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4330                 .dac_nids = alc880_dac_nids,
4331                 .dig_out_nid = ALC880_DIGOUT_NID,
4332                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4333                 .channel_mode = alc880_2_jack_modes,
4334                 .input_mux = &alc880_medion_rim_capture_source,
4335                 .unsol_event = alc880_medion_rim_unsol_event,
4336                 .setup = alc880_medion_rim_setup,
4337                 .init_hook = alc880_medion_rim_automute,
4338         },
4339 #ifdef CONFIG_SND_DEBUG
4340         [ALC880_TEST] = {
4341                 .mixers = { alc880_test_mixer },
4342                 .init_verbs = { alc880_test_init_verbs },
4343                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4344                 .dac_nids = alc880_test_dac_nids,
4345                 .dig_out_nid = ALC880_DIGOUT_NID,
4346                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4347                 .channel_mode = alc880_test_modes,
4348                 .input_mux = &alc880_test_capture_source,
4349         },
4350 #endif
4351 };
4352
4353 /*
4354  * Automatic parse of I/O pins from the BIOS configuration
4355  */
4356
4357 enum {
4358         ALC_CTL_WIDGET_VOL,
4359         ALC_CTL_WIDGET_MUTE,
4360         ALC_CTL_BIND_MUTE,
4361 };
4362 static struct snd_kcontrol_new alc880_control_templates[] = {
4363         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4364         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4365         HDA_BIND_MUTE(NULL, 0, 0, 0),
4366 };
4367
4368 /* add dynamic controls */
4369 static int add_control(struct alc_spec *spec, int type, const char *name,
4370                        unsigned long val)
4371 {
4372         struct snd_kcontrol_new *knew;
4373
4374         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4375         knew = snd_array_new(&spec->kctls);
4376         if (!knew)
4377                 return -ENOMEM;
4378         *knew = alc880_control_templates[type];
4379         knew->name = kstrdup(name, GFP_KERNEL);
4380         if (!knew->name)
4381                 return -ENOMEM;
4382         if (get_amp_nid_(val))
4383                 knew->subdevice = HDA_SUBDEV_NID_FLAG | get_amp_nid_(val);
4384         knew->private_value = val;
4385         return 0;
4386 }
4387
4388 static int add_control_with_pfx(struct alc_spec *spec, int type,
4389                                 const char *pfx, const char *dir,
4390                                 const char *sfx, unsigned long val)
4391 {
4392         char name[32];
4393         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4394         return add_control(spec, type, name, val);
4395 }
4396
4397 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4398         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4399 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4400         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4401
4402 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4403 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4404 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4405 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4406 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4407 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4408 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4409 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4410 #define ALC880_PIN_CD_NID               0x1c
4411
4412 /* fill in the dac_nids table from the parsed pin configuration */
4413 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4414                                      const struct auto_pin_cfg *cfg)
4415 {
4416         hda_nid_t nid;
4417         int assigned[4];
4418         int i, j;
4419
4420         memset(assigned, 0, sizeof(assigned));
4421         spec->multiout.dac_nids = spec->private_dac_nids;
4422
4423         /* check the pins hardwired to audio widget */
4424         for (i = 0; i < cfg->line_outs; i++) {
4425                 nid = cfg->line_out_pins[i];
4426                 if (alc880_is_fixed_pin(nid)) {
4427                         int idx = alc880_fixed_pin_idx(nid);
4428                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4429                         assigned[idx] = 1;
4430                 }
4431         }
4432         /* left pins can be connect to any audio widget */
4433         for (i = 0; i < cfg->line_outs; i++) {
4434                 nid = cfg->line_out_pins[i];
4435                 if (alc880_is_fixed_pin(nid))
4436                         continue;
4437                 /* search for an empty channel */
4438                 for (j = 0; j < cfg->line_outs; j++) {
4439                         if (!assigned[j]) {
4440                                 spec->multiout.dac_nids[i] =
4441                                         alc880_idx_to_dac(j);
4442                                 assigned[j] = 1;
4443                                 break;
4444                         }
4445                 }
4446         }
4447         spec->multiout.num_dacs = cfg->line_outs;
4448         return 0;
4449 }
4450
4451 /* add playback controls from the parsed DAC table */
4452 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4453                                              const struct auto_pin_cfg *cfg)
4454 {
4455         static const char *chname[4] = {
4456                 "Front", "Surround", NULL /*CLFE*/, "Side"
4457         };
4458         hda_nid_t nid;
4459         int i, err;
4460
4461         for (i = 0; i < cfg->line_outs; i++) {
4462                 if (!spec->multiout.dac_nids[i])
4463                         continue;
4464                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4465                 if (i == 2) {
4466                         /* Center/LFE */
4467                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4468                                               "Center",
4469                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4470                                                               HDA_OUTPUT));
4471                         if (err < 0)
4472                                 return err;
4473                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4474                                               "LFE",
4475                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4476                                                               HDA_OUTPUT));
4477                         if (err < 0)
4478                                 return err;
4479                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4480                                              "Center",
4481                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4482                                                               HDA_INPUT));
4483                         if (err < 0)
4484                                 return err;
4485                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4486                                              "LFE",
4487                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4488                                                               HDA_INPUT));
4489                         if (err < 0)
4490                                 return err;
4491                 } else {
4492                         const char *pfx;
4493                         if (cfg->line_outs == 1 &&
4494                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4495                                 pfx = "Speaker";
4496                         else
4497                                 pfx = chname[i];
4498                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4499                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4500                                                               HDA_OUTPUT));
4501                         if (err < 0)
4502                                 return err;
4503                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4504                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4505                                                               HDA_INPUT));
4506                         if (err < 0)
4507                                 return err;
4508                 }
4509         }
4510         return 0;
4511 }
4512
4513 /* add playback controls for speaker and HP outputs */
4514 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4515                                         const char *pfx)
4516 {
4517         hda_nid_t nid;
4518         int err;
4519
4520         if (!pin)
4521                 return 0;
4522
4523         if (alc880_is_fixed_pin(pin)) {
4524                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4525                 /* specify the DAC as the extra output */
4526                 if (!spec->multiout.hp_nid)
4527                         spec->multiout.hp_nid = nid;
4528                 else
4529                         spec->multiout.extra_out_nid[0] = nid;
4530                 /* control HP volume/switch on the output mixer amp */
4531                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4532                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4533                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4534                 if (err < 0)
4535                         return err;
4536                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4537                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4538                 if (err < 0)
4539                         return err;
4540         } else if (alc880_is_multi_pin(pin)) {
4541                 /* set manual connection */
4542                 /* we have only a switch on HP-out PIN */
4543                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4544                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4545                 if (err < 0)
4546                         return err;
4547         }
4548         return 0;
4549 }
4550
4551 /* create input playback/capture controls for the given pin */
4552 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4553                             const char *ctlname,
4554                             int idx, hda_nid_t mix_nid)
4555 {
4556         int err;
4557
4558         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4559                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4560         if (err < 0)
4561                 return err;
4562         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4563                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4564         if (err < 0)
4565                 return err;
4566         return 0;
4567 }
4568
4569 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4570 {
4571         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4572         return (pincap & AC_PINCAP_IN) != 0;
4573 }
4574
4575 /* create playback/capture controls for input pins */
4576 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4577                                       const struct auto_pin_cfg *cfg,
4578                                       hda_nid_t mixer,
4579                                       hda_nid_t cap1, hda_nid_t cap2)
4580 {
4581         struct alc_spec *spec = codec->spec;
4582         struct hda_input_mux *imux = &spec->private_imux[0];
4583         int i, err, idx;
4584
4585         for (i = 0; i < AUTO_PIN_LAST; i++) {
4586                 hda_nid_t pin;
4587
4588                 pin = cfg->input_pins[i];
4589                 if (!alc_is_input_pin(codec, pin))
4590                         continue;
4591
4592                 if (mixer) {
4593                         idx = get_connection_index(codec, mixer, pin);
4594                         if (idx >= 0) {
4595                                 err = new_analog_input(spec, pin,
4596                                                        auto_pin_cfg_labels[i],
4597                                                        idx, mixer);
4598                                 if (err < 0)
4599                                         return err;
4600                         }
4601                 }
4602
4603                 if (!cap1)
4604                         continue;
4605                 idx = get_connection_index(codec, cap1, pin);
4606                 if (idx < 0 && cap2)
4607                         idx = get_connection_index(codec, cap2, pin);
4608                 if (idx >= 0) {
4609                         imux->items[imux->num_items].label =
4610                                 auto_pin_cfg_labels[i];
4611                         imux->items[imux->num_items].index = idx;
4612                         imux->num_items++;
4613                 }
4614         }
4615         return 0;
4616 }
4617
4618 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4619                                                 const struct auto_pin_cfg *cfg)
4620 {
4621         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4622 }
4623
4624 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4625                                unsigned int pin_type)
4626 {
4627         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4628                             pin_type);
4629         /* unmute pin */
4630         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4631                             AMP_OUT_UNMUTE);
4632 }
4633
4634 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4635                                               hda_nid_t nid, int pin_type,
4636                                               int dac_idx)
4637 {
4638         alc_set_pin_output(codec, nid, pin_type);
4639         /* need the manual connection? */
4640         if (alc880_is_multi_pin(nid)) {
4641                 struct alc_spec *spec = codec->spec;
4642                 int idx = alc880_multi_pin_idx(nid);
4643                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4644                                     AC_VERB_SET_CONNECT_SEL,
4645                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4646         }
4647 }
4648
4649 static int get_pin_type(int line_out_type)
4650 {
4651         if (line_out_type == AUTO_PIN_HP_OUT)
4652                 return PIN_HP;
4653         else
4654                 return PIN_OUT;
4655 }
4656
4657 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4658 {
4659         struct alc_spec *spec = codec->spec;
4660         int i;
4661
4662         for (i = 0; i < spec->autocfg.line_outs; i++) {
4663                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4664                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4665                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4666         }
4667 }
4668
4669 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4670 {
4671         struct alc_spec *spec = codec->spec;
4672         hda_nid_t pin;
4673
4674         pin = spec->autocfg.speaker_pins[0];
4675         if (pin) /* connect to front */
4676                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4677         pin = spec->autocfg.hp_pins[0];
4678         if (pin) /* connect to front */
4679                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4680 }
4681
4682 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4683 {
4684         struct alc_spec *spec = codec->spec;
4685         int i;
4686
4687         for (i = 0; i < AUTO_PIN_LAST; i++) {
4688                 hda_nid_t nid = spec->autocfg.input_pins[i];
4689                 if (alc_is_input_pin(codec, nid)) {
4690                         alc_set_input_pin(codec, nid, i);
4691                         if (nid != ALC880_PIN_CD_NID &&
4692                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4693                                 snd_hda_codec_write(codec, nid, 0,
4694                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4695                                                     AMP_OUT_MUTE);
4696                 }
4697         }
4698 }
4699
4700 /* parse the BIOS configuration and set up the alc_spec */
4701 /* return 1 if successful, 0 if the proper config is not found,
4702  * or a negative error code
4703  */
4704 static int alc880_parse_auto_config(struct hda_codec *codec)
4705 {
4706         struct alc_spec *spec = codec->spec;
4707         int i, err;
4708         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4709
4710         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4711                                            alc880_ignore);
4712         if (err < 0)
4713                 return err;
4714         if (!spec->autocfg.line_outs)
4715                 return 0; /* can't find valid BIOS pin config */
4716
4717         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4718         if (err < 0)
4719                 return err;
4720         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4721         if (err < 0)
4722                 return err;
4723         err = alc880_auto_create_extra_out(spec,
4724                                            spec->autocfg.speaker_pins[0],
4725                                            "Speaker");
4726         if (err < 0)
4727                 return err;
4728         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4729                                            "Headphone");
4730         if (err < 0)
4731                 return err;
4732         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4733         if (err < 0)
4734                 return err;
4735
4736         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4737
4738         /* check multiple SPDIF-out (for recent codecs) */
4739         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4740                 hda_nid_t dig_nid;
4741                 err = snd_hda_get_connections(codec,
4742                                               spec->autocfg.dig_out_pins[i],
4743                                               &dig_nid, 1);
4744                 if (err < 0)
4745                         continue;
4746                 if (!i)
4747                         spec->multiout.dig_out_nid = dig_nid;
4748                 else {
4749                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4750                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4751                                 break;
4752                         spec->slave_dig_outs[i - 1] = dig_nid;
4753                 }
4754         }
4755         if (spec->autocfg.dig_in_pin)
4756                 spec->dig_in_nid = ALC880_DIGIN_NID;
4757
4758         if (spec->kctls.list)
4759                 add_mixer(spec, spec->kctls.list);
4760
4761         add_verb(spec, alc880_volume_init_verbs);
4762
4763         spec->num_mux_defs = 1;
4764         spec->input_mux = &spec->private_imux[0];
4765
4766         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4767
4768         return 1;
4769 }
4770
4771 /* additional initialization for auto-configuration model */
4772 static void alc880_auto_init(struct hda_codec *codec)
4773 {
4774         struct alc_spec *spec = codec->spec;
4775         alc880_auto_init_multi_out(codec);
4776         alc880_auto_init_extra_out(codec);
4777         alc880_auto_init_analog_input(codec);
4778         if (spec->unsol_event)
4779                 alc_inithook(codec);
4780 }
4781
4782 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4783  * one of two digital mic pins, e.g. on ALC272
4784  */
4785 static void fixup_automic_adc(struct hda_codec *codec)
4786 {
4787         struct alc_spec *spec = codec->spec;
4788         int i;
4789
4790         for (i = 0; i < spec->num_adc_nids; i++) {
4791                 hda_nid_t cap = spec->capsrc_nids ?
4792                         spec->capsrc_nids[i] : spec->adc_nids[i];
4793                 int iidx, eidx;
4794
4795                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4796                 if (iidx < 0)
4797                         continue;
4798                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4799                 if (eidx < 0)
4800                         continue;
4801                 spec->int_mic.mux_idx = iidx;
4802                 spec->ext_mic.mux_idx = eidx;
4803                 if (spec->capsrc_nids)
4804                         spec->capsrc_nids += i;
4805                 spec->adc_nids += i;
4806                 spec->num_adc_nids = 1;
4807                 return;
4808         }
4809         snd_printd(KERN_INFO "hda_codec: %s: "
4810                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4811                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4812         spec->auto_mic = 0; /* disable auto-mic to be sure */
4813 }
4814
4815 static void set_capture_mixer(struct hda_codec *codec)
4816 {
4817         struct alc_spec *spec = codec->spec;
4818         static struct snd_kcontrol_new *caps[2][3] = {
4819                 { alc_capture_mixer_nosrc1,
4820                   alc_capture_mixer_nosrc2,
4821                   alc_capture_mixer_nosrc3 },
4822                 { alc_capture_mixer1,
4823                   alc_capture_mixer2,
4824                   alc_capture_mixer3 },
4825         };
4826         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4827                 int mux;
4828                 if (spec->auto_mic) {
4829                         mux = 0;
4830                         fixup_automic_adc(codec);
4831                 } else if (spec->input_mux && spec->input_mux->num_items > 1)
4832                         mux = 1;
4833                 else
4834                         mux = 0;
4835                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4836         }
4837 }
4838
4839 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4840 #define set_beep_amp(spec, nid, idx, dir) \
4841         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4842 #else
4843 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
4844 #endif
4845
4846 /*
4847  * OK, here we have finally the patch for ALC880
4848  */
4849
4850 static int patch_alc880(struct hda_codec *codec)
4851 {
4852         struct alc_spec *spec;
4853         int board_config;
4854         int err;
4855
4856         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4857         if (spec == NULL)
4858                 return -ENOMEM;
4859
4860         codec->spec = spec;
4861
4862         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4863                                                   alc880_models,
4864                                                   alc880_cfg_tbl);
4865         if (board_config < 0) {
4866                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4867                        codec->chip_name);
4868                 board_config = ALC880_AUTO;
4869         }
4870
4871         if (board_config == ALC880_AUTO) {
4872                 /* automatic parse from the BIOS config */
4873                 err = alc880_parse_auto_config(codec);
4874                 if (err < 0) {
4875                         alc_free(codec);
4876                         return err;
4877                 } else if (!err) {
4878                         printk(KERN_INFO
4879                                "hda_codec: Cannot set up configuration "
4880                                "from BIOS.  Using 3-stack mode...\n");
4881                         board_config = ALC880_3ST;
4882                 }
4883         }
4884
4885         err = snd_hda_attach_beep_device(codec, 0x1);
4886         if (err < 0) {
4887                 alc_free(codec);
4888                 return err;
4889         }
4890
4891         if (board_config != ALC880_AUTO)
4892                 setup_preset(codec, &alc880_presets[board_config]);
4893
4894         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4895         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4896         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4897
4898         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4899         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4900
4901         if (!spec->adc_nids && spec->input_mux) {
4902                 /* check whether NID 0x07 is valid */
4903                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4904                 /* get type */
4905                 wcap = get_wcaps_type(wcap);
4906                 if (wcap != AC_WID_AUD_IN) {
4907                         spec->adc_nids = alc880_adc_nids_alt;
4908                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4909                 } else {
4910                         spec->adc_nids = alc880_adc_nids;
4911                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4912                 }
4913         }
4914         set_capture_mixer(codec);
4915         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4916
4917         spec->vmaster_nid = 0x0c;
4918
4919         codec->patch_ops = alc_patch_ops;
4920         if (board_config == ALC880_AUTO)
4921                 spec->init_hook = alc880_auto_init;
4922 #ifdef CONFIG_SND_HDA_POWER_SAVE
4923         if (!spec->loopback.amplist)
4924                 spec->loopback.amplist = alc880_loopbacks;
4925 #endif
4926         codec->proc_widget_hook = print_realtek_coef;
4927
4928         return 0;
4929 }
4930
4931
4932 /*
4933  * ALC260 support
4934  */
4935
4936 static hda_nid_t alc260_dac_nids[1] = {
4937         /* front */
4938         0x02,
4939 };
4940
4941 static hda_nid_t alc260_adc_nids[1] = {
4942         /* ADC0 */
4943         0x04,
4944 };
4945
4946 static hda_nid_t alc260_adc_nids_alt[1] = {
4947         /* ADC1 */
4948         0x05,
4949 };
4950
4951 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4952  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4953  */
4954 static hda_nid_t alc260_dual_adc_nids[2] = {
4955         /* ADC0, ADC1 */
4956         0x04, 0x05
4957 };
4958
4959 #define ALC260_DIGOUT_NID       0x03
4960 #define ALC260_DIGIN_NID        0x06
4961
4962 static struct hda_input_mux alc260_capture_source = {
4963         .num_items = 4,
4964         .items = {
4965                 { "Mic", 0x0 },
4966                 { "Front Mic", 0x1 },
4967                 { "Line", 0x2 },
4968                 { "CD", 0x4 },
4969         },
4970 };
4971
4972 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4973  * headphone jack and the internal CD lines since these are the only pins at
4974  * which audio can appear.  For flexibility, also allow the option of
4975  * recording the mixer output on the second ADC (ADC0 doesn't have a
4976  * connection to the mixer output).
4977  */
4978 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4979         {
4980                 .num_items = 3,
4981                 .items = {
4982                         { "Mic/Line", 0x0 },
4983                         { "CD", 0x4 },
4984                         { "Headphone", 0x2 },
4985                 },
4986         },
4987         {
4988                 .num_items = 4,
4989                 .items = {
4990                         { "Mic/Line", 0x0 },
4991                         { "CD", 0x4 },
4992                         { "Headphone", 0x2 },
4993                         { "Mixer", 0x5 },
4994                 },
4995         },
4996
4997 };
4998
4999 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5000  * the Fujitsu S702x, but jacks are marked differently.
5001  */
5002 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5003         {
5004                 .num_items = 4,
5005                 .items = {
5006                         { "Mic", 0x0 },
5007                         { "Line", 0x2 },
5008                         { "CD", 0x4 },
5009                         { "Headphone", 0x5 },
5010                 },
5011         },
5012         {
5013                 .num_items = 5,
5014                 .items = {
5015                         { "Mic", 0x0 },
5016                         { "Line", 0x2 },
5017                         { "CD", 0x4 },
5018                         { "Headphone", 0x6 },
5019                         { "Mixer", 0x5 },
5020                 },
5021         },
5022 };
5023
5024 /* Maxdata Favorit 100XS */
5025 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5026         {
5027                 .num_items = 2,
5028                 .items = {
5029                         { "Line/Mic", 0x0 },
5030                         { "CD", 0x4 },
5031                 },
5032         },
5033         {
5034                 .num_items = 3,
5035                 .items = {
5036                         { "Line/Mic", 0x0 },
5037                         { "CD", 0x4 },
5038                         { "Mixer", 0x5 },
5039                 },
5040         },
5041 };
5042
5043 /*
5044  * This is just place-holder, so there's something for alc_build_pcms to look
5045  * at when it calculates the maximum number of channels. ALC260 has no mixer
5046  * element which allows changing the channel mode, so the verb list is
5047  * never used.
5048  */
5049 static struct hda_channel_mode alc260_modes[1] = {
5050         { 2, NULL },
5051 };
5052
5053
5054 /* Mixer combinations
5055  *
5056  * basic: base_output + input + pc_beep + capture
5057  * HP: base_output + input + capture_alt
5058  * HP_3013: hp_3013 + input + capture
5059  * fujitsu: fujitsu + capture
5060  * acer: acer + capture
5061  */
5062
5063 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5064         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5065         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5066         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5067         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5068         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5069         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5070         { } /* end */
5071 };
5072
5073 static struct snd_kcontrol_new alc260_input_mixer[] = {
5074         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5075         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5076         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5077         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5078         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5079         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5080         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5081         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5082         { } /* end */
5083 };
5084
5085 /* update HP, line and mono out pins according to the master switch */
5086 static void alc260_hp_master_update(struct hda_codec *codec,
5087                                     hda_nid_t hp, hda_nid_t line,
5088                                     hda_nid_t mono)
5089 {
5090         struct alc_spec *spec = codec->spec;
5091         unsigned int val = spec->master_sw ? PIN_HP : 0;
5092         /* change HP and line-out pins */
5093         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5094                             val);
5095         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5096                             val);
5097         /* mono (speaker) depending on the HP jack sense */
5098         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5099         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5100                             val);
5101 }
5102
5103 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5104                                    struct snd_ctl_elem_value *ucontrol)
5105 {
5106         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5107         struct alc_spec *spec = codec->spec;
5108         *ucontrol->value.integer.value = spec->master_sw;
5109         return 0;
5110 }
5111
5112 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5113                                    struct snd_ctl_elem_value *ucontrol)
5114 {
5115         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5116         struct alc_spec *spec = codec->spec;
5117         int val = !!*ucontrol->value.integer.value;
5118         hda_nid_t hp, line, mono;
5119
5120         if (val == spec->master_sw)
5121                 return 0;
5122         spec->master_sw = val;
5123         hp = (kcontrol->private_value >> 16) & 0xff;
5124         line = (kcontrol->private_value >> 8) & 0xff;
5125         mono = kcontrol->private_value & 0xff;
5126         alc260_hp_master_update(codec, hp, line, mono);
5127         return 1;
5128 }
5129
5130 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5131         {
5132                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5133                 .name = "Master Playback Switch",
5134                 .info = snd_ctl_boolean_mono_info,
5135                 .get = alc260_hp_master_sw_get,
5136                 .put = alc260_hp_master_sw_put,
5137                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5138         },
5139         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5140         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5141         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5142         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5143         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5144                               HDA_OUTPUT),
5145         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5146         { } /* end */
5147 };
5148
5149 static struct hda_verb alc260_hp_unsol_verbs[] = {
5150         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5151         {},
5152 };
5153
5154 static void alc260_hp_automute(struct hda_codec *codec)
5155 {
5156         struct alc_spec *spec = codec->spec;
5157
5158         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5159         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5160 }
5161
5162 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5163 {
5164         if ((res >> 26) == ALC880_HP_EVENT)
5165                 alc260_hp_automute(codec);
5166 }
5167
5168 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5169         {
5170                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5171                 .name = "Master Playback Switch",
5172                 .info = snd_ctl_boolean_mono_info,
5173                 .get = alc260_hp_master_sw_get,
5174                 .put = alc260_hp_master_sw_put,
5175                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5176         },
5177         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5178         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5179         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5180         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5181         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5182         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5183         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5184         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5185         { } /* end */
5186 };
5187
5188 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5189         .ops = &snd_hda_bind_vol,
5190         .values = {
5191                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5192                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5193                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5194                 0
5195         },
5196 };
5197
5198 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5199         .ops = &snd_hda_bind_sw,
5200         .values = {
5201                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5202                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5203                 0
5204         },
5205 };
5206
5207 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5208         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5209         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5210         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5211         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5212         { } /* end */
5213 };
5214
5215 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5216         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5217         {},
5218 };
5219
5220 static void alc260_hp_3013_automute(struct hda_codec *codec)
5221 {
5222         struct alc_spec *spec = codec->spec;
5223
5224         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5225         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5226 }
5227
5228 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5229                                        unsigned int res)
5230 {
5231         if ((res >> 26) == ALC880_HP_EVENT)
5232                 alc260_hp_3013_automute(codec);
5233 }
5234
5235 static void alc260_hp_3012_automute(struct hda_codec *codec)
5236 {
5237         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5238
5239         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5240                             bits);
5241         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5242                             bits);
5243         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5244                             bits);
5245 }
5246
5247 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5248                                        unsigned int res)
5249 {
5250         if ((res >> 26) == ALC880_HP_EVENT)
5251                 alc260_hp_3012_automute(codec);
5252 }
5253
5254 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5255  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5256  */
5257 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5258         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5259         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5260         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5261         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5262         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5263         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5264         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5265         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5266         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5267         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5268         { } /* end */
5269 };
5270
5271 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5272  * versions of the ALC260 don't act on requests to enable mic bias from NID
5273  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5274  * datasheet doesn't mention this restriction.  At this stage it's not clear
5275  * whether this behaviour is intentional or is a hardware bug in chip
5276  * revisions available in early 2006.  Therefore for now allow the
5277  * "Headphone Jack Mode" control to span all choices, but if it turns out
5278  * that the lack of mic bias for this NID is intentional we could change the
5279  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5280  *
5281  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5282  * don't appear to make the mic bias available from the "line" jack, even
5283  * though the NID used for this jack (0x14) can supply it.  The theory is
5284  * that perhaps Acer have included blocking capacitors between the ALC260
5285  * and the output jack.  If this turns out to be the case for all such
5286  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5287  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5288  *
5289  * The C20x Tablet series have a mono internal speaker which is controlled
5290  * via the chip's Mono sum widget and pin complex, so include the necessary
5291  * controls for such models.  On models without a "mono speaker" the control
5292  * won't do anything.
5293  */
5294 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5295         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5296         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5297         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5298         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5299                               HDA_OUTPUT),
5300         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5301                            HDA_INPUT),
5302         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5303         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5304         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5305         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5306         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5307         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5308         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5309         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5310         { } /* end */
5311 };
5312
5313 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5314  */
5315 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5316         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5317         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5318         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5319         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5320         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5321         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5322         { } /* end */
5323 };
5324
5325 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5326  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5327  */
5328 static struct snd_kcontrol_new alc260_will_mixer[] = {
5329         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5330         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5331         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5332         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5333         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5334         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5335         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5336         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5337         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5338         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5339         { } /* end */
5340 };
5341
5342 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5343  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5344  */
5345 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5346         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5347         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5348         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5349         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5350         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5351         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5352         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5353         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5354         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5355         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5356         { } /* end */
5357 };
5358
5359 /*
5360  * initialization verbs
5361  */
5362 static struct hda_verb alc260_init_verbs[] = {
5363         /* Line In pin widget for input */
5364         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5365         /* CD pin widget for input */
5366         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5367         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5368         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5369         /* Mic2 (front panel) pin widget for input and vref at 80% */
5370         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5371         /* LINE-2 is used for line-out in rear */
5372         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5373         /* select line-out */
5374         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5375         /* LINE-OUT pin */
5376         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5377         /* enable HP */
5378         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5379         /* enable Mono */
5380         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5381         /* mute capture amp left and right */
5382         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5383         /* set connection select to line in (default select for this ADC) */
5384         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5385         /* mute capture amp left and right */
5386         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5387         /* set connection select to line in (default select for this ADC) */
5388         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5389         /* set vol=0 Line-Out mixer amp left and right */
5390         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5391         /* unmute pin widget amp left and right (no gain on this amp) */
5392         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5393         /* set vol=0 HP mixer amp left and right */
5394         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5395         /* unmute pin widget amp left and right (no gain on this amp) */
5396         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5397         /* set vol=0 Mono mixer amp left and right */
5398         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5399         /* unmute pin widget amp left and right (no gain on this amp) */
5400         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5401         /* unmute LINE-2 out pin */
5402         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5403         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5404          * Line In 2 = 0x03
5405          */
5406         /* mute analog inputs */
5407         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5408         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5409         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5410         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5411         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5412         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5413         /* mute Front out path */
5414         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5415         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5416         /* mute Headphone out path */
5417         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5418         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5419         /* mute Mono out path */
5420         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5421         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5422         { }
5423 };
5424
5425 #if 0 /* should be identical with alc260_init_verbs? */
5426 static struct hda_verb alc260_hp_init_verbs[] = {
5427         /* Headphone and output */
5428         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5429         /* mono output */
5430         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5431         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5432         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5433         /* Mic2 (front panel) pin widget for input and vref at 80% */
5434         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5435         /* Line In pin widget for input */
5436         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5437         /* Line-2 pin widget for output */
5438         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5439         /* CD pin widget for input */
5440         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5441         /* unmute amp left and right */
5442         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5443         /* set connection select to line in (default select for this ADC) */
5444         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5445         /* unmute Line-Out mixer amp left and right (volume = 0) */
5446         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5447         /* mute pin widget amp left and right (no gain on this amp) */
5448         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5449         /* unmute HP mixer amp left and right (volume = 0) */
5450         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5451         /* mute pin widget amp left and right (no gain on this amp) */
5452         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5453         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5454          * Line In 2 = 0x03
5455          */
5456         /* mute analog inputs */
5457         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5458         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5459         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5462         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5463         /* Unmute Front out path */
5464         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5465         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5466         /* Unmute Headphone out path */
5467         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5468         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5469         /* Unmute Mono out path */
5470         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5471         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5472         { }
5473 };
5474 #endif
5475
5476 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5477         /* Line out and output */
5478         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5479         /* mono output */
5480         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5481         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5482         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5483         /* Mic2 (front panel) pin widget for input and vref at 80% */
5484         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5485         /* Line In pin widget for input */
5486         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5487         /* Headphone pin widget for output */
5488         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5489         /* CD pin widget for input */
5490         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5491         /* unmute amp left and right */
5492         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5493         /* set connection select to line in (default select for this ADC) */
5494         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5495         /* unmute Line-Out mixer amp left and right (volume = 0) */
5496         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5497         /* mute pin widget amp left and right (no gain on this amp) */
5498         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5499         /* unmute HP mixer amp left and right (volume = 0) */
5500         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5501         /* mute pin widget amp left and right (no gain on this amp) */
5502         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5503         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5504          * Line In 2 = 0x03
5505          */
5506         /* mute analog inputs */
5507         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5508         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5509         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5510         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5511         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5512         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5513         /* Unmute Front out path */
5514         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5515         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5516         /* Unmute Headphone out path */
5517         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5518         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5519         /* Unmute Mono out path */
5520         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5521         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5522         { }
5523 };
5524
5525 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5526  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5527  * audio = 0x16, internal speaker = 0x10.
5528  */
5529 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5530         /* Disable all GPIOs */
5531         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5532         /* Internal speaker is connected to headphone pin */
5533         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5534         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5535         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5536         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5537         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5538         /* Ensure all other unused pins are disabled and muted. */
5539         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5540         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5541         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5542         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5543         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5544         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5545         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5546         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5547
5548         /* Disable digital (SPDIF) pins */
5549         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5550         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5551
5552         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5553          * when acting as an output.
5554          */
5555         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5556
5557         /* Start with output sum widgets muted and their output gains at min */
5558         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5559         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5560         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5561         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5562         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5563         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5564         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5565         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5566         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5567
5568         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5569         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5570         /* Unmute Line1 pin widget output buffer since it starts as an output.
5571          * If the pin mode is changed by the user the pin mode control will
5572          * take care of enabling the pin's input/output buffers as needed.
5573          * Therefore there's no need to enable the input buffer at this
5574          * stage.
5575          */
5576         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5577         /* Unmute input buffer of pin widget used for Line-in (no equiv
5578          * mixer ctrl)
5579          */
5580         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5581
5582         /* Mute capture amp left and right */
5583         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5584         /* Set ADC connection select to match default mixer setting - line
5585          * in (on mic1 pin)
5586          */
5587         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5588
5589         /* Do the same for the second ADC: mute capture input amp and
5590          * set ADC connection to line in (on mic1 pin)
5591          */
5592         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5593         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5594
5595         /* Mute all inputs to mixer widget (even unconnected ones) */
5596         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5597         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5598         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5599         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5600         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5601         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5603         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5604
5605         { }
5606 };
5607
5608 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5609  * similar laptops (adapted from Fujitsu init verbs).
5610  */
5611 static struct hda_verb alc260_acer_init_verbs[] = {
5612         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5613          * the headphone jack.  Turn this on and rely on the standard mute
5614          * methods whenever the user wants to turn these outputs off.
5615          */
5616         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5617         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5618         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5619         /* Internal speaker/Headphone jack is connected to Line-out pin */
5620         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5621         /* Internal microphone/Mic jack is connected to Mic1 pin */
5622         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5623         /* Line In jack is connected to Line1 pin */
5624         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5625         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5626         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5627         /* Ensure all other unused pins are disabled and muted. */
5628         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5629         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5630         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5631         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5632         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5633         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5634         /* Disable digital (SPDIF) pins */
5635         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5636         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5637
5638         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5639          * bus when acting as outputs.
5640          */
5641         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5642         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5643
5644         /* Start with output sum widgets muted and their output gains at min */
5645         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5646         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5647         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5648         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5649         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5650         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5651         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5652         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5653         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5654
5655         /* Unmute Line-out pin widget amp left and right
5656          * (no equiv mixer ctrl)
5657          */
5658         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5659         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5660         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5661         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5662          * inputs. If the pin mode is changed by the user the pin mode control
5663          * will take care of enabling the pin's input/output buffers as needed.
5664          * Therefore there's no need to enable the input buffer at this
5665          * stage.
5666          */
5667         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5668         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5669
5670         /* Mute capture amp left and right */
5671         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5672         /* Set ADC connection select to match default mixer setting - mic
5673          * (on mic1 pin)
5674          */
5675         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5676
5677         /* Do similar with the second ADC: mute capture input amp and
5678          * set ADC connection to mic to match ALSA's default state.
5679          */
5680         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5681         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5682
5683         /* Mute all inputs to mixer widget (even unconnected ones) */
5684         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5685         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5686         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5687         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5688         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5689         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5690         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5691         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5692
5693         { }
5694 };
5695
5696 /* Initialisation sequence for Maxdata Favorit 100XS
5697  * (adapted from Acer init verbs).
5698  */
5699 static struct hda_verb alc260_favorit100_init_verbs[] = {
5700         /* GPIO 0 enables the output jack.
5701          * Turn this on and rely on the standard mute
5702          * methods whenever the user wants to turn these outputs off.
5703          */
5704         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5705         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5706         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5707         /* Line/Mic input jack is connected to Mic1 pin */
5708         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5709         /* Ensure all other unused pins are disabled and muted. */
5710         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5711         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5712         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5713         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5714         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5715         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5716         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5717         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5718         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5719         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5720         /* Disable digital (SPDIF) pins */
5721         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5722         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5723
5724         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5725          * bus when acting as outputs.
5726          */
5727         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5728         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5729
5730         /* Start with output sum widgets muted and their output gains at min */
5731         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5732         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5733         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5734         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5735         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5736         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5737         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5738         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5739         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5740
5741         /* Unmute Line-out pin widget amp left and right
5742          * (no equiv mixer ctrl)
5743          */
5744         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5745         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5746          * inputs. If the pin mode is changed by the user the pin mode control
5747          * will take care of enabling the pin's input/output buffers as needed.
5748          * Therefore there's no need to enable the input buffer at this
5749          * stage.
5750          */
5751         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5752
5753         /* Mute capture amp left and right */
5754         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5755         /* Set ADC connection select to match default mixer setting - mic
5756          * (on mic1 pin)
5757          */
5758         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5759
5760         /* Do similar with the second ADC: mute capture input amp and
5761          * set ADC connection to mic to match ALSA's default state.
5762          */
5763         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5764         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5765
5766         /* Mute all inputs to mixer widget (even unconnected ones) */
5767         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5768         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5769         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5770         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5771         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5772         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5773         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5774         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5775
5776         { }
5777 };
5778
5779 static struct hda_verb alc260_will_verbs[] = {
5780         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5781         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5782         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5783         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5784         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5785         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5786         {}
5787 };
5788
5789 static struct hda_verb alc260_replacer_672v_verbs[] = {
5790         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5791         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5792         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5793
5794         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5795         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5796         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5797
5798         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5799         {}
5800 };
5801
5802 /* toggle speaker-output according to the hp-jack state */
5803 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5804 {
5805         unsigned int present;
5806
5807         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5808         present = snd_hda_jack_detect(codec, 0x0f);
5809         if (present) {
5810                 snd_hda_codec_write_cache(codec, 0x01, 0,
5811                                           AC_VERB_SET_GPIO_DATA, 1);
5812                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5813                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5814                                           PIN_HP);
5815         } else {
5816                 snd_hda_codec_write_cache(codec, 0x01, 0,
5817                                           AC_VERB_SET_GPIO_DATA, 0);
5818                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5819                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5820                                           PIN_OUT);
5821         }
5822 }
5823
5824 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5825                                        unsigned int res)
5826 {
5827         if ((res >> 26) == ALC880_HP_EVENT)
5828                 alc260_replacer_672v_automute(codec);
5829 }
5830
5831 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5832         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5833         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5834         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5835         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5836         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5838         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5839         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5840         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5841         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5842         {}
5843 };
5844
5845 /* Test configuration for debugging, modelled after the ALC880 test
5846  * configuration.
5847  */
5848 #ifdef CONFIG_SND_DEBUG
5849 static hda_nid_t alc260_test_dac_nids[1] = {
5850         0x02,
5851 };
5852 static hda_nid_t alc260_test_adc_nids[2] = {
5853         0x04, 0x05,
5854 };
5855 /* For testing the ALC260, each input MUX needs its own definition since
5856  * the signal assignments are different.  This assumes that the first ADC
5857  * is NID 0x04.
5858  */
5859 static struct hda_input_mux alc260_test_capture_sources[2] = {
5860         {
5861                 .num_items = 7,
5862                 .items = {
5863                         { "MIC1 pin", 0x0 },
5864                         { "MIC2 pin", 0x1 },
5865                         { "LINE1 pin", 0x2 },
5866                         { "LINE2 pin", 0x3 },
5867                         { "CD pin", 0x4 },
5868                         { "LINE-OUT pin", 0x5 },
5869                         { "HP-OUT pin", 0x6 },
5870                 },
5871         },
5872         {
5873                 .num_items = 8,
5874                 .items = {
5875                         { "MIC1 pin", 0x0 },
5876                         { "MIC2 pin", 0x1 },
5877                         { "LINE1 pin", 0x2 },
5878                         { "LINE2 pin", 0x3 },
5879                         { "CD pin", 0x4 },
5880                         { "Mixer", 0x5 },
5881                         { "LINE-OUT pin", 0x6 },
5882                         { "HP-OUT pin", 0x7 },
5883                 },
5884         },
5885 };
5886 static struct snd_kcontrol_new alc260_test_mixer[] = {
5887         /* Output driver widgets */
5888         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5889         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5890         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5891         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5892         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5893         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5894
5895         /* Modes for retasking pin widgets
5896          * Note: the ALC260 doesn't seem to act on requests to enable mic
5897          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5898          * mention this restriction.  At this stage it's not clear whether
5899          * this behaviour is intentional or is a hardware bug in chip
5900          * revisions available at least up until early 2006.  Therefore for
5901          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5902          * choices, but if it turns out that the lack of mic bias for these
5903          * NIDs is intentional we could change their modes from
5904          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5905          */
5906         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5907         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5908         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5909         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5910         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5911         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5912
5913         /* Loopback mixer controls */
5914         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5915         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5916         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5917         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5918         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5919         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5920         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5921         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5922         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5923         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5924         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5925         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5926         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5927         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5928
5929         /* Controls for GPIO pins, assuming they are configured as outputs */
5930         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5931         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5932         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5933         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5934
5935         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5936          * is ambigious as to which NID is which; testing on laptops which
5937          * make this output available should provide clarification.
5938          */
5939         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5940         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5941
5942         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5943          * this output to turn on an external amplifier.
5944          */
5945         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5946         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5947
5948         { } /* end */
5949 };
5950 static struct hda_verb alc260_test_init_verbs[] = {
5951         /* Enable all GPIOs as outputs with an initial value of 0 */
5952         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5953         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5954         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5955
5956         /* Enable retasking pins as output, initially without power amp */
5957         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5958         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5959         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5960         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5961         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5962         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5963
5964         /* Disable digital (SPDIF) pins initially, but users can enable
5965          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5966          * payload also sets the generation to 0, output to be in "consumer"
5967          * PCM format, copyright asserted, no pre-emphasis and no validity
5968          * control.
5969          */
5970         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5971         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5972
5973         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5974          * OUT1 sum bus when acting as an output.
5975          */
5976         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5977         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5978         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5979         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5980
5981         /* Start with output sum widgets muted and their output gains at min */
5982         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5983         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5984         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5985         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5986         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5987         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5988         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5989         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5990         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5991
5992         /* Unmute retasking pin widget output buffers since the default
5993          * state appears to be output.  As the pin mode is changed by the
5994          * user the pin mode control will take care of enabling the pin's
5995          * input/output buffers as needed.
5996          */
5997         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5998         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5999         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6000         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6001         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6002         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6003         /* Also unmute the mono-out pin widget */
6004         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6005
6006         /* Mute capture amp left and right */
6007         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6008         /* Set ADC connection select to match default mixer setting (mic1
6009          * pin)
6010          */
6011         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6012
6013         /* Do the same for the second ADC: mute capture input amp and
6014          * set ADC connection to mic1 pin
6015          */
6016         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6017         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6018
6019         /* Mute all inputs to mixer widget (even unconnected ones) */
6020         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6021         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6022         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6023         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6024         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6025         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6026         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6027         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6028
6029         { }
6030 };
6031 #endif
6032
6033 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6034 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6035
6036 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6037 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6038
6039 /*
6040  * for BIOS auto-configuration
6041  */
6042
6043 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6044                                         const char *pfx, int *vol_bits)
6045 {
6046         hda_nid_t nid_vol;
6047         unsigned long vol_val, sw_val;
6048         int err;
6049
6050         if (nid >= 0x0f && nid < 0x11) {
6051                 nid_vol = nid - 0x7;
6052                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6053                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6054         } else if (nid == 0x11) {
6055                 nid_vol = nid - 0x7;
6056                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6057                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6058         } else if (nid >= 0x12 && nid <= 0x15) {
6059                 nid_vol = 0x08;
6060                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6061                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6062         } else
6063                 return 0; /* N/A */
6064
6065         if (!(*vol_bits & (1 << nid_vol))) {
6066                 /* first control for the volume widget */
6067                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6068                 if (err < 0)
6069                         return err;
6070                 *vol_bits |= (1 << nid_vol);
6071         }
6072         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6073         if (err < 0)
6074                 return err;
6075         return 1;
6076 }
6077
6078 /* add playback controls from the parsed DAC table */
6079 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6080                                              const struct auto_pin_cfg *cfg)
6081 {
6082         hda_nid_t nid;
6083         int err;
6084         int vols = 0;
6085
6086         spec->multiout.num_dacs = 1;
6087         spec->multiout.dac_nids = spec->private_dac_nids;
6088         spec->multiout.dac_nids[0] = 0x02;
6089
6090         nid = cfg->line_out_pins[0];
6091         if (nid) {
6092                 const char *pfx;
6093                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6094                         pfx = "Master";
6095                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6096                         pfx = "Speaker";
6097                 else
6098                         pfx = "Front";
6099                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6100                 if (err < 0)
6101                         return err;
6102         }
6103
6104         nid = cfg->speaker_pins[0];
6105         if (nid) {
6106                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6107                 if (err < 0)
6108                         return err;
6109         }
6110
6111         nid = cfg->hp_pins[0];
6112         if (nid) {
6113                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6114                                                    &vols);
6115                 if (err < 0)
6116                         return err;
6117         }
6118         return 0;
6119 }
6120
6121 /* create playback/capture controls for input pins */
6122 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6123                                                 const struct auto_pin_cfg *cfg)
6124 {
6125         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6126 }
6127
6128 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6129                                               hda_nid_t nid, int pin_type,
6130                                               int sel_idx)
6131 {
6132         alc_set_pin_output(codec, nid, pin_type);
6133         /* need the manual connection? */
6134         if (nid >= 0x12) {
6135                 int idx = nid - 0x12;
6136                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6137                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6138         }
6139 }
6140
6141 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6142 {
6143         struct alc_spec *spec = codec->spec;
6144         hda_nid_t nid;
6145
6146         nid = spec->autocfg.line_out_pins[0];
6147         if (nid) {
6148                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6149                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6150         }
6151
6152         nid = spec->autocfg.speaker_pins[0];
6153         if (nid)
6154                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6155
6156         nid = spec->autocfg.hp_pins[0];
6157         if (nid)
6158                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6159 }
6160
6161 #define ALC260_PIN_CD_NID               0x16
6162 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6163 {
6164         struct alc_spec *spec = codec->spec;
6165         int i;
6166
6167         for (i = 0; i < AUTO_PIN_LAST; i++) {
6168                 hda_nid_t nid = spec->autocfg.input_pins[i];
6169                 if (nid >= 0x12) {
6170                         alc_set_input_pin(codec, nid, i);
6171                         if (nid != ALC260_PIN_CD_NID &&
6172                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6173                                 snd_hda_codec_write(codec, nid, 0,
6174                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6175                                                     AMP_OUT_MUTE);
6176                 }
6177         }
6178 }
6179
6180 /*
6181  * generic initialization of ADC, input mixers and output mixers
6182  */
6183 static struct hda_verb alc260_volume_init_verbs[] = {
6184         /*
6185          * Unmute ADC0-1 and set the default input to mic-in
6186          */
6187         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6188         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6189         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6190         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6191
6192         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6193          * mixer widget
6194          * Note: PASD motherboards uses the Line In 2 as the input for
6195          * front panel mic (mic 2)
6196          */
6197         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6198         /* mute analog inputs */
6199         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6200         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6201         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6202         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6203         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6204
6205         /*
6206          * Set up output mixers (0x08 - 0x0a)
6207          */
6208         /* set vol=0 to output mixers */
6209         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6210         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6211         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6212         /* set up input amps for analog loopback */
6213         /* Amp Indices: DAC = 0, mixer = 1 */
6214         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6215         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6216         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6217         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6218         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6219         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6220
6221         { }
6222 };
6223
6224 static int alc260_parse_auto_config(struct hda_codec *codec)
6225 {
6226         struct alc_spec *spec = codec->spec;
6227         int err;
6228         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6229
6230         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6231                                            alc260_ignore);
6232         if (err < 0)
6233                 return err;
6234         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6235         if (err < 0)
6236                 return err;
6237         if (!spec->kctls.list)
6238                 return 0; /* can't find valid BIOS pin config */
6239         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6240         if (err < 0)
6241                 return err;
6242
6243         spec->multiout.max_channels = 2;
6244
6245         if (spec->autocfg.dig_outs)
6246                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6247         if (spec->kctls.list)
6248                 add_mixer(spec, spec->kctls.list);
6249
6250         add_verb(spec, alc260_volume_init_verbs);
6251
6252         spec->num_mux_defs = 1;
6253         spec->input_mux = &spec->private_imux[0];
6254
6255         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6256
6257         return 1;
6258 }
6259
6260 /* additional initialization for auto-configuration model */
6261 static void alc260_auto_init(struct hda_codec *codec)
6262 {
6263         struct alc_spec *spec = codec->spec;
6264         alc260_auto_init_multi_out(codec);
6265         alc260_auto_init_analog_input(codec);
6266         if (spec->unsol_event)
6267                 alc_inithook(codec);
6268 }
6269
6270 #ifdef CONFIG_SND_HDA_POWER_SAVE
6271 static struct hda_amp_list alc260_loopbacks[] = {
6272         { 0x07, HDA_INPUT, 0 },
6273         { 0x07, HDA_INPUT, 1 },
6274         { 0x07, HDA_INPUT, 2 },
6275         { 0x07, HDA_INPUT, 3 },
6276         { 0x07, HDA_INPUT, 4 },
6277         { } /* end */
6278 };
6279 #endif
6280
6281 /*
6282  * ALC260 configurations
6283  */
6284 static const char *alc260_models[ALC260_MODEL_LAST] = {
6285         [ALC260_BASIC]          = "basic",
6286         [ALC260_HP]             = "hp",
6287         [ALC260_HP_3013]        = "hp-3013",
6288         [ALC260_HP_DC7600]      = "hp-dc7600",
6289         [ALC260_FUJITSU_S702X]  = "fujitsu",
6290         [ALC260_ACER]           = "acer",
6291         [ALC260_WILL]           = "will",
6292         [ALC260_REPLACER_672V]  = "replacer",
6293         [ALC260_FAVORIT100]     = "favorit100",
6294 #ifdef CONFIG_SND_DEBUG
6295         [ALC260_TEST]           = "test",
6296 #endif
6297         [ALC260_AUTO]           = "auto",
6298 };
6299
6300 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6301         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6302         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6303         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6304         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6305         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6306         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6307         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6308         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6309         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6310         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6311         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6312         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6313         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6314         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6315         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6316         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6317         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6318         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6319         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6320         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6321         {}
6322 };
6323
6324 static struct alc_config_preset alc260_presets[] = {
6325         [ALC260_BASIC] = {
6326                 .mixers = { alc260_base_output_mixer,
6327                             alc260_input_mixer },
6328                 .init_verbs = { alc260_init_verbs },
6329                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6330                 .dac_nids = alc260_dac_nids,
6331                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6332                 .adc_nids = alc260_adc_nids,
6333                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6334                 .channel_mode = alc260_modes,
6335                 .input_mux = &alc260_capture_source,
6336         },
6337         [ALC260_HP] = {
6338                 .mixers = { alc260_hp_output_mixer,
6339                             alc260_input_mixer },
6340                 .init_verbs = { alc260_init_verbs,
6341                                 alc260_hp_unsol_verbs },
6342                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6343                 .dac_nids = alc260_dac_nids,
6344                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6345                 .adc_nids = alc260_adc_nids_alt,
6346                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6347                 .channel_mode = alc260_modes,
6348                 .input_mux = &alc260_capture_source,
6349                 .unsol_event = alc260_hp_unsol_event,
6350                 .init_hook = alc260_hp_automute,
6351         },
6352         [ALC260_HP_DC7600] = {
6353                 .mixers = { alc260_hp_dc7600_mixer,
6354                             alc260_input_mixer },
6355                 .init_verbs = { alc260_init_verbs,
6356                                 alc260_hp_dc7600_verbs },
6357                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6358                 .dac_nids = alc260_dac_nids,
6359                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6360                 .adc_nids = alc260_adc_nids_alt,
6361                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6362                 .channel_mode = alc260_modes,
6363                 .input_mux = &alc260_capture_source,
6364                 .unsol_event = alc260_hp_3012_unsol_event,
6365                 .init_hook = alc260_hp_3012_automute,
6366         },
6367         [ALC260_HP_3013] = {
6368                 .mixers = { alc260_hp_3013_mixer,
6369                             alc260_input_mixer },
6370                 .init_verbs = { alc260_hp_3013_init_verbs,
6371                                 alc260_hp_3013_unsol_verbs },
6372                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6373                 .dac_nids = alc260_dac_nids,
6374                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6375                 .adc_nids = alc260_adc_nids_alt,
6376                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6377                 .channel_mode = alc260_modes,
6378                 .input_mux = &alc260_capture_source,
6379                 .unsol_event = alc260_hp_3013_unsol_event,
6380                 .init_hook = alc260_hp_3013_automute,
6381         },
6382         [ALC260_FUJITSU_S702X] = {
6383                 .mixers = { alc260_fujitsu_mixer },
6384                 .init_verbs = { alc260_fujitsu_init_verbs },
6385                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6386                 .dac_nids = alc260_dac_nids,
6387                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6388                 .adc_nids = alc260_dual_adc_nids,
6389                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6390                 .channel_mode = alc260_modes,
6391                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6392                 .input_mux = alc260_fujitsu_capture_sources,
6393         },
6394         [ALC260_ACER] = {
6395                 .mixers = { alc260_acer_mixer },
6396                 .init_verbs = { alc260_acer_init_verbs },
6397                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6398                 .dac_nids = alc260_dac_nids,
6399                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6400                 .adc_nids = alc260_dual_adc_nids,
6401                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6402                 .channel_mode = alc260_modes,
6403                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6404                 .input_mux = alc260_acer_capture_sources,
6405         },
6406         [ALC260_FAVORIT100] = {
6407                 .mixers = { alc260_favorit100_mixer },
6408                 .init_verbs = { alc260_favorit100_init_verbs },
6409                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6410                 .dac_nids = alc260_dac_nids,
6411                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6412                 .adc_nids = alc260_dual_adc_nids,
6413                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6414                 .channel_mode = alc260_modes,
6415                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6416                 .input_mux = alc260_favorit100_capture_sources,
6417         },
6418         [ALC260_WILL] = {
6419                 .mixers = { alc260_will_mixer },
6420                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6421                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6422                 .dac_nids = alc260_dac_nids,
6423                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6424                 .adc_nids = alc260_adc_nids,
6425                 .dig_out_nid = ALC260_DIGOUT_NID,
6426                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6427                 .channel_mode = alc260_modes,
6428                 .input_mux = &alc260_capture_source,
6429         },
6430         [ALC260_REPLACER_672V] = {
6431                 .mixers = { alc260_replacer_672v_mixer },
6432                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6433                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6434                 .dac_nids = alc260_dac_nids,
6435                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6436                 .adc_nids = alc260_adc_nids,
6437                 .dig_out_nid = ALC260_DIGOUT_NID,
6438                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6439                 .channel_mode = alc260_modes,
6440                 .input_mux = &alc260_capture_source,
6441                 .unsol_event = alc260_replacer_672v_unsol_event,
6442                 .init_hook = alc260_replacer_672v_automute,
6443         },
6444 #ifdef CONFIG_SND_DEBUG
6445         [ALC260_TEST] = {
6446                 .mixers = { alc260_test_mixer },
6447                 .init_verbs = { alc260_test_init_verbs },
6448                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6449                 .dac_nids = alc260_test_dac_nids,
6450                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6451                 .adc_nids = alc260_test_adc_nids,
6452                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6453                 .channel_mode = alc260_modes,
6454                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6455                 .input_mux = alc260_test_capture_sources,
6456         },
6457 #endif
6458 };
6459
6460 static int patch_alc260(struct hda_codec *codec)
6461 {
6462         struct alc_spec *spec;
6463         int err, board_config;
6464
6465         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6466         if (spec == NULL)
6467                 return -ENOMEM;
6468
6469         codec->spec = spec;
6470
6471         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6472                                                   alc260_models,
6473                                                   alc260_cfg_tbl);
6474         if (board_config < 0) {
6475                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6476                            codec->chip_name);
6477                 board_config = ALC260_AUTO;
6478         }
6479
6480         if (board_config == ALC260_AUTO) {
6481                 /* automatic parse from the BIOS config */
6482                 err = alc260_parse_auto_config(codec);
6483                 if (err < 0) {
6484                         alc_free(codec);
6485                         return err;
6486                 } else if (!err) {
6487                         printk(KERN_INFO
6488                                "hda_codec: Cannot set up configuration "
6489                                "from BIOS.  Using base mode...\n");
6490                         board_config = ALC260_BASIC;
6491                 }
6492         }
6493
6494         err = snd_hda_attach_beep_device(codec, 0x1);
6495         if (err < 0) {
6496                 alc_free(codec);
6497                 return err;
6498         }
6499
6500         if (board_config != ALC260_AUTO)
6501                 setup_preset(codec, &alc260_presets[board_config]);
6502
6503         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6504         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6505
6506         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6507         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6508
6509         if (!spec->adc_nids && spec->input_mux) {
6510                 /* check whether NID 0x04 is valid */
6511                 unsigned int wcap = get_wcaps(codec, 0x04);
6512                 wcap = get_wcaps_type(wcap);
6513                 /* get type */
6514                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6515                         spec->adc_nids = alc260_adc_nids_alt;
6516                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6517                 } else {
6518                         spec->adc_nids = alc260_adc_nids;
6519                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6520                 }
6521         }
6522         set_capture_mixer(codec);
6523         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6524
6525         spec->vmaster_nid = 0x08;
6526
6527         codec->patch_ops = alc_patch_ops;
6528         if (board_config == ALC260_AUTO)
6529                 spec->init_hook = alc260_auto_init;
6530 #ifdef CONFIG_SND_HDA_POWER_SAVE
6531         if (!spec->loopback.amplist)
6532                 spec->loopback.amplist = alc260_loopbacks;
6533 #endif
6534         codec->proc_widget_hook = print_realtek_coef;
6535
6536         return 0;
6537 }
6538
6539
6540 /*
6541  * ALC882/883/885/888/889 support
6542  *
6543  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6544  * configuration.  Each pin widget can choose any input DACs and a mixer.
6545  * Each ADC is connected from a mixer of all inputs.  This makes possible
6546  * 6-channel independent captures.
6547  *
6548  * In addition, an independent DAC for the multi-playback (not used in this
6549  * driver yet).
6550  */
6551 #define ALC882_DIGOUT_NID       0x06
6552 #define ALC882_DIGIN_NID        0x0a
6553 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6554 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6555 #define ALC1200_DIGOUT_NID      0x10
6556
6557
6558 static struct hda_channel_mode alc882_ch_modes[1] = {
6559         { 8, NULL }
6560 };
6561
6562 /* DACs */
6563 static hda_nid_t alc882_dac_nids[4] = {
6564         /* front, rear, clfe, rear_surr */
6565         0x02, 0x03, 0x04, 0x05
6566 };
6567 #define alc883_dac_nids         alc882_dac_nids
6568
6569 /* ADCs */
6570 #define alc882_adc_nids         alc880_adc_nids
6571 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6572 #define alc883_adc_nids         alc882_adc_nids_alt
6573 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6574 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6575 #define alc889_adc_nids         alc880_adc_nids
6576
6577 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6578 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6579 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6580 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6581 #define alc889_capsrc_nids      alc882_capsrc_nids
6582
6583 /* input MUX */
6584 /* FIXME: should be a matrix-type input source selection */
6585
6586 static struct hda_input_mux alc882_capture_source = {
6587         .num_items = 4,
6588         .items = {
6589                 { "Mic", 0x0 },
6590                 { "Front Mic", 0x1 },
6591                 { "Line", 0x2 },
6592                 { "CD", 0x4 },
6593         },
6594 };
6595
6596 #define alc883_capture_source   alc882_capture_source
6597
6598 static struct hda_input_mux alc889_capture_source = {
6599         .num_items = 3,
6600         .items = {
6601                 { "Front Mic", 0x0 },
6602                 { "Mic", 0x3 },
6603                 { "Line", 0x2 },
6604         },
6605 };
6606
6607 static struct hda_input_mux mb5_capture_source = {
6608         .num_items = 3,
6609         .items = {
6610                 { "Mic", 0x1 },
6611                 { "Line", 0x2 },
6612                 { "CD", 0x4 },
6613         },
6614 };
6615
6616 static struct hda_input_mux alc883_3stack_6ch_intel = {
6617         .num_items = 4,
6618         .items = {
6619                 { "Mic", 0x1 },
6620                 { "Front Mic", 0x0 },
6621                 { "Line", 0x2 },
6622                 { "CD", 0x4 },
6623         },
6624 };
6625
6626 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6627         .num_items = 2,
6628         .items = {
6629                 { "Mic", 0x1 },
6630                 { "Line", 0x2 },
6631         },
6632 };
6633
6634 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6635         .num_items = 4,
6636         .items = {
6637                 { "Mic", 0x0 },
6638                 { "iMic", 0x1 },
6639                 { "Line", 0x2 },
6640                 { "CD", 0x4 },
6641         },
6642 };
6643
6644 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6645         .num_items = 2,
6646         .items = {
6647                 { "Mic", 0x0 },
6648                 { "Int Mic", 0x1 },
6649         },
6650 };
6651
6652 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6653         .num_items = 3,
6654         .items = {
6655                 { "Mic", 0x0 },
6656                 { "Front Mic", 0x1 },
6657                 { "Line", 0x4 },
6658         },
6659 };
6660
6661 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6662         .num_items = 2,
6663         .items = {
6664                 { "Mic", 0x0 },
6665                 { "Line", 0x2 },
6666         },
6667 };
6668
6669 static struct hda_input_mux alc889A_mb31_capture_source = {
6670         .num_items = 2,
6671         .items = {
6672                 { "Mic", 0x0 },
6673                 /* Front Mic (0x01) unused */
6674                 { "Line", 0x2 },
6675                 /* Line 2 (0x03) unused */
6676                 /* CD (0x04) unused? */
6677         },
6678 };
6679
6680 /*
6681  * 2ch mode
6682  */
6683 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6684         { 2, NULL }
6685 };
6686
6687 /*
6688  * 2ch mode
6689  */
6690 static struct hda_verb alc882_3ST_ch2_init[] = {
6691         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6692         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6693         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6694         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6695         { } /* end */
6696 };
6697
6698 /*
6699  * 4ch mode
6700  */
6701 static struct hda_verb alc882_3ST_ch4_init[] = {
6702         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6703         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6704         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6705         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6706         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6707         { } /* end */
6708 };
6709
6710 /*
6711  * 6ch mode
6712  */
6713 static struct hda_verb alc882_3ST_ch6_init[] = {
6714         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6715         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6716         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6717         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6718         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6719         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6720         { } /* end */
6721 };
6722
6723 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6724         { 2, alc882_3ST_ch2_init },
6725         { 4, alc882_3ST_ch4_init },
6726         { 6, alc882_3ST_ch6_init },
6727 };
6728
6729 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6730
6731 /*
6732  * 2ch mode
6733  */
6734 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6735         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6736         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6737         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6738         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6739         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6740         { } /* end */
6741 };
6742
6743 /*
6744  * 4ch mode
6745  */
6746 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6747         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6748         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6749         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6750         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6751         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6752         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6753         { } /* end */
6754 };
6755
6756 /*
6757  * 6ch mode
6758  */
6759 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6760         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6761         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6762         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6763         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6764         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6765         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6766         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6767         { } /* end */
6768 };
6769
6770 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6771         { 2, alc883_3ST_ch2_clevo_init },
6772         { 4, alc883_3ST_ch4_clevo_init },
6773         { 6, alc883_3ST_ch6_clevo_init },
6774 };
6775
6776
6777 /*
6778  * 6ch mode
6779  */
6780 static struct hda_verb alc882_sixstack_ch6_init[] = {
6781         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6782         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6783         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6784         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6785         { } /* end */
6786 };
6787
6788 /*
6789  * 8ch mode
6790  */
6791 static struct hda_verb alc882_sixstack_ch8_init[] = {
6792         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6793         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6794         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6795         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6796         { } /* end */
6797 };
6798
6799 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6800         { 6, alc882_sixstack_ch6_init },
6801         { 8, alc882_sixstack_ch8_init },
6802 };
6803
6804 /*
6805  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6806  */
6807
6808 /*
6809  * 2ch mode
6810  */
6811 static struct hda_verb alc885_mbp_ch2_init[] = {
6812         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6813         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6814         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6815         { } /* end */
6816 };
6817
6818 /*
6819  * 4ch mode
6820  */
6821 static struct hda_verb alc885_mbp_ch4_init[] = {
6822         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6823         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6824         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6825         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6826         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6827         { } /* end */
6828 };
6829
6830 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6831         { 2, alc885_mbp_ch2_init },
6832         { 4, alc885_mbp_ch4_init },
6833 };
6834
6835 /*
6836  * 2ch
6837  * Speakers/Woofer/HP = Front
6838  * LineIn = Input
6839  */
6840 static struct hda_verb alc885_mb5_ch2_init[] = {
6841         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6842         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6843         { } /* end */
6844 };
6845
6846 /*
6847  * 6ch mode
6848  * Speakers/HP = Front
6849  * Woofer = LFE
6850  * LineIn = Surround
6851  */
6852 static struct hda_verb alc885_mb5_ch6_init[] = {
6853         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6855         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6856         { } /* end */
6857 };
6858
6859 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6860         { 2, alc885_mb5_ch2_init },
6861         { 6, alc885_mb5_ch6_init },
6862 };
6863
6864
6865 /*
6866  * 2ch mode
6867  */
6868 static struct hda_verb alc883_4ST_ch2_init[] = {
6869         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6870         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6871         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6872         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6873         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6874         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6875         { } /* end */
6876 };
6877
6878 /*
6879  * 4ch mode
6880  */
6881 static struct hda_verb alc883_4ST_ch4_init[] = {
6882         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6883         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6884         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6885         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6886         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6887         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6888         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6889         { } /* end */
6890 };
6891
6892 /*
6893  * 6ch mode
6894  */
6895 static struct hda_verb alc883_4ST_ch6_init[] = {
6896         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6897         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6898         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6899         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6900         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6901         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6902         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6903         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6904         { } /* end */
6905 };
6906
6907 /*
6908  * 8ch mode
6909  */
6910 static struct hda_verb alc883_4ST_ch8_init[] = {
6911         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6912         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6913         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6914         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6915         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6916         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6917         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6918         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6919         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6920         { } /* end */
6921 };
6922
6923 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6924         { 2, alc883_4ST_ch2_init },
6925         { 4, alc883_4ST_ch4_init },
6926         { 6, alc883_4ST_ch6_init },
6927         { 8, alc883_4ST_ch8_init },
6928 };
6929
6930
6931 /*
6932  * 2ch mode
6933  */
6934 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6935         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6936         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6937         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6938         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6939         { } /* end */
6940 };
6941
6942 /*
6943  * 4ch mode
6944  */
6945 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6946         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6947         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6948         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6949         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6950         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6951         { } /* end */
6952 };
6953
6954 /*
6955  * 6ch mode
6956  */
6957 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6958         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6959         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6960         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
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, 0x01 },
6964         { } /* end */
6965 };
6966
6967 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6968         { 2, alc883_3ST_ch2_intel_init },
6969         { 4, alc883_3ST_ch4_intel_init },
6970         { 6, alc883_3ST_ch6_intel_init },
6971 };
6972
6973 /*
6974  * 2ch mode
6975  */
6976 static struct hda_verb alc889_ch2_intel_init[] = {
6977         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6978         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
6979         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
6980         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
6981         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6982         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6983         { } /* end */
6984 };
6985
6986 /*
6987  * 6ch mode
6988  */
6989 static struct hda_verb alc889_ch6_intel_init[] = {
6990         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6991         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6992         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6993         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6994         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6995         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6996         { } /* end */
6997 };
6998
6999 /*
7000  * 8ch mode
7001  */
7002 static struct hda_verb alc889_ch8_intel_init[] = {
7003         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7004         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7005         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7006         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7007         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7008         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7009         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7010         { } /* end */
7011 };
7012
7013 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7014         { 2, alc889_ch2_intel_init },
7015         { 6, alc889_ch6_intel_init },
7016         { 8, alc889_ch8_intel_init },
7017 };
7018
7019 /*
7020  * 6ch mode
7021  */
7022 static struct hda_verb alc883_sixstack_ch6_init[] = {
7023         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7024         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7025         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7026         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7027         { } /* end */
7028 };
7029
7030 /*
7031  * 8ch mode
7032  */
7033 static struct hda_verb alc883_sixstack_ch8_init[] = {
7034         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7035         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7036         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7037         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7038         { } /* end */
7039 };
7040
7041 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7042         { 6, alc883_sixstack_ch6_init },
7043         { 8, alc883_sixstack_ch8_init },
7044 };
7045
7046
7047 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7048  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7049  */
7050 static struct snd_kcontrol_new alc882_base_mixer[] = {
7051         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7052         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7053         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7054         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7055         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7056         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7057         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7058         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7059         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7060         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7061         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7062         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7063         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7065         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7067         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7068         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7069         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7070         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7071         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7072         { } /* end */
7073 };
7074
7075 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7076         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7077         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7078         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7079         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7080         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7081         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7082         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7083         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7084         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7085         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7086         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7087         { } /* end */
7088 };
7089
7090 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7092         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7093         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7094         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7095         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7096         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7097         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7098         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
7099         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7100         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7101         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7102         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7103         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7105         { } /* end */
7106 };
7107
7108 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7109         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7110         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7111         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7112         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7113         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7114         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7115         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7116         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7117         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7118         { } /* end */
7119 };
7120
7121
7122 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7123         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7124         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7125         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7126         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7127         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7128         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7130         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7131         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7132         { } /* end */
7133 };
7134
7135 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7136         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7137         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7138         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7139         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7140         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7141         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7142         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7143         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7144         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7145         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7146         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7147         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7148         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7149         { } /* end */
7150 };
7151
7152 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7153  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7154  */
7155 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7156         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7157         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7158         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7159         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7160         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7161         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7162         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7163         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7164         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7165         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7167         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7168         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7169         { } /* end */
7170 };
7171
7172 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7173         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7174         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7175         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7176         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7177         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7178         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7179         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7181         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7182         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7183         { } /* end */
7184 };
7185
7186 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7187         {
7188                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7189                 .name = "Channel Mode",
7190                 .info = alc_ch_mode_info,
7191                 .get = alc_ch_mode_get,
7192                 .put = alc_ch_mode_put,
7193         },
7194         { } /* end */
7195 };
7196
7197 static struct hda_verb alc882_base_init_verbs[] = {
7198         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7199         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7200         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7201         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7202         /* Rear mixer */
7203         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7204         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7205         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7206         /* CLFE mixer */
7207         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7208         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7209         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7210         /* Side mixer */
7211         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7212         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7213         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7214
7215         /* mute analog input loopbacks */
7216         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7217         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7218         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7219         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7220         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7221
7222         /* Front Pin: output 0 (0x0c) */
7223         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7224         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7225         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7226         /* Rear Pin: output 1 (0x0d) */
7227         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7228         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7229         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7230         /* CLFE Pin: output 2 (0x0e) */
7231         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7232         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7233         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7234         /* Side Pin: output 3 (0x0f) */
7235         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7236         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7237         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7238         /* Mic (rear) pin: input vref at 80% */
7239         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7240         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7241         /* Front Mic pin: input vref at 80% */
7242         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7243         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7244         /* Line In pin: input */
7245         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7246         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7247         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7248         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7249         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7250         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7251         /* CD pin widget for input */
7252         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7253
7254         /* FIXME: use matrix-type input source selection */
7255         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7256         /* Input mixer2 */
7257         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7258         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7259         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7260         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7261         /* Input mixer3 */
7262         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7263         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7264         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7266         /* ADC2: mute amp left and right */
7267         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7268         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7269         /* ADC3: mute amp left and right */
7270         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7271         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7272
7273         { }
7274 };
7275
7276 static struct hda_verb alc882_adc1_init_verbs[] = {
7277         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7278         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7279         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7280         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7281         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7282         /* ADC1: mute amp left and right */
7283         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7284         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7285         { }
7286 };
7287
7288 static struct hda_verb alc882_eapd_verbs[] = {
7289         /* change to EAPD mode */
7290         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7291         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7292         { }
7293 };
7294
7295 static struct hda_verb alc889_eapd_verbs[] = {
7296         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7297         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7298         { }
7299 };
7300
7301 static struct hda_verb alc_hp15_unsol_verbs[] = {
7302         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7303         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7304         {}
7305 };
7306
7307 static struct hda_verb alc885_init_verbs[] = {
7308         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7312         /* Rear mixer */
7313         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7314         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7315         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7316         /* CLFE mixer */
7317         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7318         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7319         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7320         /* Side mixer */
7321         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7322         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7323         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7324
7325         /* mute analog input loopbacks */
7326         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7327         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7328         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7329
7330         /* Front HP Pin: output 0 (0x0c) */
7331         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7332         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7333         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7334         /* Front Pin: output 0 (0x0c) */
7335         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7336         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7337         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7338         /* Rear Pin: output 1 (0x0d) */
7339         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7341         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7342         /* CLFE Pin: output 2 (0x0e) */
7343         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7344         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7345         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7346         /* Side Pin: output 3 (0x0f) */
7347         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7348         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7349         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7350         /* Mic (rear) pin: input vref at 80% */
7351         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7352         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7353         /* Front Mic pin: input vref at 80% */
7354         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7355         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7356         /* Line In pin: input */
7357         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7358         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7359
7360         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7361         /* Input mixer1 */
7362         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7364         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7365         /* Input mixer2 */
7366         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7367         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7368         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7369         /* Input mixer3 */
7370         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7371         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7372         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7373         /* ADC2: mute amp left and right */
7374         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7375         /* ADC3: mute amp left and right */
7376         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7377
7378         { }
7379 };
7380
7381 static struct hda_verb alc885_init_input_verbs[] = {
7382         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7383         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7384         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7385         { }
7386 };
7387
7388
7389 /* Unmute Selector 24h and set the default input to front mic */
7390 static struct hda_verb alc889_init_input_verbs[] = {
7391         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7392         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7393         { }
7394 };
7395
7396
7397 #define alc883_init_verbs       alc882_base_init_verbs
7398
7399 /* Mac Pro test */
7400 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7401         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7402         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7403         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7404         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7405         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7406         /* FIXME: this looks suspicious...
7407         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7408         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7409         */
7410         { } /* end */
7411 };
7412
7413 static struct hda_verb alc882_macpro_init_verbs[] = {
7414         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7416         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7417         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7418         /* Front Pin: output 0 (0x0c) */
7419         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7420         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7421         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7422         /* Front Mic pin: input vref at 80% */
7423         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7424         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7425         /* Speaker:  output */
7426         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7427         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7428         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7429         /* Headphone output (output 0 - 0x0c) */
7430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7431         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7432         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7433
7434         /* FIXME: use matrix-type input source selection */
7435         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7436         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7438         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7439         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7440         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7441         /* Input mixer2 */
7442         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7443         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7444         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7445         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7446         /* Input mixer3 */
7447         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7448         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7449         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7450         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7451         /* ADC1: mute amp left and right */
7452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7453         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7454         /* ADC2: mute amp left and right */
7455         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7456         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7457         /* ADC3: mute amp left and right */
7458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7459         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7460
7461         { }
7462 };
7463
7464 /* Macbook 5,1 */
7465 static struct hda_verb alc885_mb5_init_verbs[] = {
7466         /* DACs */
7467         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7468         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7469         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7470         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7471         /* Front mixer */
7472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7473         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7474         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7475         /* Surround mixer */
7476         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7478         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7479         /* LFE mixer */
7480         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7481         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7482         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7483         /* HP mixer */
7484         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7485         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7486         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7487         /* Front Pin (0x0c) */
7488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7490         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7491         /* LFE Pin (0x0e) */
7492         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7493         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7494         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7495         /* HP Pin (0x0f) */
7496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7498         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7499         /* Front Mic pin: input vref at 80% */
7500         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7501         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7502         /* Line In pin */
7503         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7504         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7505
7506         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7507         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7508         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7509         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7510         { }
7511 };
7512
7513 /* Macbook Pro rev3 */
7514 static struct hda_verb alc885_mbp3_init_verbs[] = {
7515         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7516         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7517         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7518         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7519         /* Rear mixer */
7520         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7521         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7522         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7523         /* HP mixer */
7524         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7525         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7526         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7527         /* Front Pin: output 0 (0x0c) */
7528         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7529         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7530         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7531         /* HP Pin: output 0 (0x0e) */
7532         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7533         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7534         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7535         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7536         /* Mic (rear) pin: input vref at 80% */
7537         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7538         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7539         /* Front Mic pin: input vref at 80% */
7540         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7541         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7542         /* Line In pin: use output 1 when in LineOut mode */
7543         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7544         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7545         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7546
7547         /* FIXME: use matrix-type input source selection */
7548         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7549         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7550         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7551         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7552         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7553         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7554         /* Input mixer2 */
7555         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7556         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7557         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7558         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7559         /* Input mixer3 */
7560         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7561         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7562         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7563         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7564         /* ADC1: mute amp left and right */
7565         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7566         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7567         /* ADC2: mute amp left and right */
7568         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7569         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7570         /* ADC3: mute amp left and right */
7571         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7572         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7573
7574         { }
7575 };
7576
7577 /* iMac 9,1 */
7578 static struct hda_verb alc885_imac91_init_verbs[] = {
7579         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7581         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7582         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7583         /* Rear mixer */
7584         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7585         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7586         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7587         /* HP Pin: output 0 (0x0c) */
7588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7589         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7590         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7591         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7592         /* Internal Speakers: output 0 (0x0d) */
7593         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7594         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7595         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7596         /* Mic (rear) pin: input vref at 80% */
7597         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7598         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7599         /* Front Mic pin: input vref at 80% */
7600         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7601         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7602         /* Line In pin: use output 1 when in LineOut mode */
7603         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7604         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7605         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7606
7607         /* FIXME: use matrix-type input source selection */
7608         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7609         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7613         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7614         /* Input mixer2 */
7615         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7616         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7617         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7618         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7619         /* Input mixer3 */
7620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7623         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7624         /* ADC1: mute amp left and right */
7625         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7626         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7627         /* ADC2: mute amp left and right */
7628         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7629         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7630         /* ADC3: mute amp left and right */
7631         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7632         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7633
7634         { }
7635 };
7636
7637 /* iMac 24 mixer. */
7638 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7639         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7640         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7641         { } /* end */
7642 };
7643
7644 /* iMac 24 init verbs. */
7645 static struct hda_verb alc885_imac24_init_verbs[] = {
7646         /* Internal speakers: output 0 (0x0c) */
7647         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7648         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7649         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7650         /* Internal speakers: output 0 (0x0c) */
7651         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7652         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7653         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7654         /* Headphone: output 0 (0x0c) */
7655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7657         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7658         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7659         /* Front Mic: input vref at 80% */
7660         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7661         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7662         { }
7663 };
7664
7665 /* Toggle speaker-output according to the hp-jack state */
7666 static void alc885_imac24_setup(struct hda_codec *codec)
7667 {
7668         struct alc_spec *spec = codec->spec;
7669
7670         spec->autocfg.hp_pins[0] = 0x14;
7671         spec->autocfg.speaker_pins[0] = 0x18;
7672         spec->autocfg.speaker_pins[1] = 0x1a;
7673 }
7674
7675 static void alc885_mbp3_setup(struct hda_codec *codec)
7676 {
7677         struct alc_spec *spec = codec->spec;
7678
7679         spec->autocfg.hp_pins[0] = 0x15;
7680         spec->autocfg.speaker_pins[0] = 0x14;
7681 }
7682
7683 static void alc885_imac91_automute(struct hda_codec *codec)
7684 {
7685         unsigned int present;
7686
7687         present = snd_hda_codec_read(codec, 0x14, 0,
7688                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7689         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7690                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7691         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
7692                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7693
7694 }
7695
7696 static void alc885_imac91_unsol_event(struct hda_codec *codec,
7697                                     unsigned int res)
7698 {
7699         /* Headphone insertion or removal. */
7700         if ((res >> 26) == ALC880_HP_EVENT)
7701                 alc885_imac91_automute(codec);
7702 }
7703
7704 static struct hda_verb alc882_targa_verbs[] = {
7705         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7706         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7707
7708         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7709         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7710
7711         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7712         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7713         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7714
7715         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7716         { } /* end */
7717 };
7718
7719 /* toggle speaker-output according to the hp-jack state */
7720 static void alc882_targa_automute(struct hda_codec *codec)
7721 {
7722         struct alc_spec *spec = codec->spec;
7723         alc_automute_amp(codec);
7724         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7725                                   spec->jack_present ? 1 : 3);
7726 }
7727
7728 static void alc882_targa_setup(struct hda_codec *codec)
7729 {
7730         struct alc_spec *spec = codec->spec;
7731
7732         spec->autocfg.hp_pins[0] = 0x14;
7733         spec->autocfg.speaker_pins[0] = 0x1b;
7734 }
7735
7736 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7737 {
7738         if ((res >> 26) == ALC880_HP_EVENT)
7739                 alc882_targa_automute(codec);
7740 }
7741
7742 static struct hda_verb alc882_asus_a7j_verbs[] = {
7743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7744         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7745
7746         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7747         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7748         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7749
7750         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7751         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7752         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7753
7754         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7755         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7756         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7757         { } /* end */
7758 };
7759
7760 static struct hda_verb alc882_asus_a7m_verbs[] = {
7761         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7762         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7763
7764         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7765         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7766         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7767
7768         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7769         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7770         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7771
7772         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7773         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7774         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7775         { } /* end */
7776 };
7777
7778 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7779 {
7780         unsigned int gpiostate, gpiomask, gpiodir;
7781
7782         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7783                                        AC_VERB_GET_GPIO_DATA, 0);
7784
7785         if (!muted)
7786                 gpiostate |= (1 << pin);
7787         else
7788                 gpiostate &= ~(1 << pin);
7789
7790         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7791                                       AC_VERB_GET_GPIO_MASK, 0);
7792         gpiomask |= (1 << pin);
7793
7794         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7795                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7796         gpiodir |= (1 << pin);
7797
7798
7799         snd_hda_codec_write(codec, codec->afg, 0,
7800                             AC_VERB_SET_GPIO_MASK, gpiomask);
7801         snd_hda_codec_write(codec, codec->afg, 0,
7802                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7803
7804         msleep(1);
7805
7806         snd_hda_codec_write(codec, codec->afg, 0,
7807                             AC_VERB_SET_GPIO_DATA, gpiostate);
7808 }
7809
7810 /* set up GPIO at initialization */
7811 static void alc885_macpro_init_hook(struct hda_codec *codec)
7812 {
7813         alc882_gpio_mute(codec, 0, 0);
7814         alc882_gpio_mute(codec, 1, 0);
7815 }
7816
7817 /* set up GPIO and update auto-muting at initialization */
7818 static void alc885_imac24_init_hook(struct hda_codec *codec)
7819 {
7820         alc885_macpro_init_hook(codec);
7821         alc_automute_amp(codec);
7822 }
7823
7824 /*
7825  * generic initialization of ADC, input mixers and output mixers
7826  */
7827 static struct hda_verb alc883_auto_init_verbs[] = {
7828         /*
7829          * Unmute ADC0-2 and set the default input to mic-in
7830          */
7831         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7832         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7833         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7834         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7835
7836         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7837          * mixer widget
7838          * Note: PASD motherboards uses the Line In 2 as the input for
7839          * front panel mic (mic 2)
7840          */
7841         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7842         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7843         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7844         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7845         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7846         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7847
7848         /*
7849          * Set up output mixers (0x0c - 0x0f)
7850          */
7851         /* set vol=0 to output mixers */
7852         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7853         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7854         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7855         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7856         /* set up input amps for analog loopback */
7857         /* Amp Indices: DAC = 0, mixer = 1 */
7858         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7859         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7860         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7861         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7862         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7863         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7864         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7865         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7866         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7867         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7868
7869         /* FIXME: use matrix-type input source selection */
7870         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7871         /* Input mixer2 */
7872         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7873         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7874         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7875         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7876         /* Input mixer3 */
7877         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7878         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7879         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7880         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7881
7882         { }
7883 };
7884
7885 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7886 static struct hda_verb alc889A_mb31_ch2_init[] = {
7887         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7888         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7889         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7890         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7891         { } /* end */
7892 };
7893
7894 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7895 static struct hda_verb alc889A_mb31_ch4_init[] = {
7896         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7897         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7898         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7899         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7900         { } /* end */
7901 };
7902
7903 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7904 static struct hda_verb alc889A_mb31_ch5_init[] = {
7905         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7906         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7907         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7908         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7909         { } /* end */
7910 };
7911
7912 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7913 static struct hda_verb alc889A_mb31_ch6_init[] = {
7914         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7915         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7916         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7917         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7918         { } /* end */
7919 };
7920
7921 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7922         { 2, alc889A_mb31_ch2_init },
7923         { 4, alc889A_mb31_ch4_init },
7924         { 5, alc889A_mb31_ch5_init },
7925         { 6, alc889A_mb31_ch6_init },
7926 };
7927
7928 static struct hda_verb alc883_medion_eapd_verbs[] = {
7929         /* eanable EAPD on medion laptop */
7930         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7931         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7932         { }
7933 };
7934
7935 #define alc883_base_mixer       alc882_base_mixer
7936
7937 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7938         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7939         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7940         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7941         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7942         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7943         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7944         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7945         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7946         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7947         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7948         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7949         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7950         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7951         { } /* end */
7952 };
7953
7954 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7955         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7956         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7957         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7958         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7959         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7961         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7962         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7963         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7964         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7965         { } /* end */
7966 };
7967
7968 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7969         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7970         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7971         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7972         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7974         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7976         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7977         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7978         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7979         { } /* end */
7980 };
7981
7982 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7983         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7984         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7985         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7986         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7987         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7988         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7989         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7990         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7991         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7992         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7993         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7995         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7996         { } /* end */
7997 };
7998
7999 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8000         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8001         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8002         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8003         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8004         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8005         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8006         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8007         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8008         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8009         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8010         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8011         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8012         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8013         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8014         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8015         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8016         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8017         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8018         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8019         { } /* end */
8020 };
8021
8022 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8023         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8024         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8025         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8026         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8027         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8028                               HDA_OUTPUT),
8029         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8030         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8031         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8032         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8033         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8034         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8035         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8036         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8038         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8039         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8040         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8041         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8042         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8043         { } /* end */
8044 };
8045
8046 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8047         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8048         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8049         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8050         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8051         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8052                               HDA_OUTPUT),
8053         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8054         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8055         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8056         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8057         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8058         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8059         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8060         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8061         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8062         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8063         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8064         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8065         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8066         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8067         { } /* end */
8068 };
8069
8070 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8071         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8072         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8073         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8074         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8075         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8076         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8077         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8078         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8079         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8080         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8081         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8082         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8083         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8084         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8085         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8086         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8087         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8088         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8089         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8090         { } /* end */
8091 };
8092
8093 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8094         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8095         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8096         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8097         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8098         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8099         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8100         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8101         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8102         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8103         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8104         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8105         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8106         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8107         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8108         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8109         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8110         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8111         { } /* end */
8112 };
8113
8114 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8115         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8116         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8117         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8118         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8119         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8120         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8121         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8122         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8123         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8124         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8125         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8126         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8127         { } /* end */
8128 };
8129
8130 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8131         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8132         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8133         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8134         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8135         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8136         { } /* end */
8137 };
8138
8139 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8140         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8141         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8142         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8143         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8144         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8145         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8146         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8148         { } /* end */
8149 };
8150
8151 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8152         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8153         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8154         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8155         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8156         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8157         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8158         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8159         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8160         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8161         { } /* end */
8162 };
8163
8164 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8165         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8166         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8167         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8168         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8169         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8170         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8171         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8172         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8173         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8174         { } /* end */
8175 };
8176
8177 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8178         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8179         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8180         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8181         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8182         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8183         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8184         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8185         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8186         { } /* end */
8187 };
8188
8189 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8190         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8191         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8192         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8193         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8194         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8195         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8196         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8197         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8198         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8199         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8200         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8201         { } /* end */
8202 };
8203
8204 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8205         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8206         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8207         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8208         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8209         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8210                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8211         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8212         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8213         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8214         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8215         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8216         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8217         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8218         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8219         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8221         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8223         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8224         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8225         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8226         { } /* end */
8227 };
8228
8229 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8230         /* Output mixers */
8231         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8232         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8233         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8234         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8235         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8236                 HDA_OUTPUT),
8237         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8238         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8239         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8240         /* Output switches */
8241         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8242         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8243         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8244         /* Boost mixers */
8245         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8246         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8247         /* Input mixers */
8248         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8249         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8252         { } /* end */
8253 };
8254
8255 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8256         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8257         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8258         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8259         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8260         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8261         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8262         { } /* end */
8263 };
8264
8265 static struct hda_bind_ctls alc883_bind_cap_vol = {
8266         .ops = &snd_hda_bind_vol,
8267         .values = {
8268                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8269                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8270                 0
8271         },
8272 };
8273
8274 static struct hda_bind_ctls alc883_bind_cap_switch = {
8275         .ops = &snd_hda_bind_sw,
8276         .values = {
8277                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8278                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8279                 0
8280         },
8281 };
8282
8283 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8284         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8285         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8286         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8287         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8288         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8290         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8291         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8292         { } /* end */
8293 };
8294
8295 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8296         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8297         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8298         {
8299                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8300                 /* .name = "Capture Source", */
8301                 .name = "Input Source",
8302                 .count = 1,
8303                 .info = alc_mux_enum_info,
8304                 .get = alc_mux_enum_get,
8305                 .put = alc_mux_enum_put,
8306         },
8307         { } /* end */
8308 };
8309
8310 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8311         {
8312                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8313                 .name = "Channel Mode",
8314                 .info = alc_ch_mode_info,
8315                 .get = alc_ch_mode_get,
8316                 .put = alc_ch_mode_put,
8317         },
8318         { } /* end */
8319 };
8320
8321 /* toggle speaker-output according to the hp-jack state */
8322 static void alc883_mitac_setup(struct hda_codec *codec)
8323 {
8324         struct alc_spec *spec = codec->spec;
8325
8326         spec->autocfg.hp_pins[0] = 0x15;
8327         spec->autocfg.speaker_pins[0] = 0x14;
8328         spec->autocfg.speaker_pins[1] = 0x17;
8329 }
8330
8331 /* auto-toggle front mic */
8332 /*
8333 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8334 {
8335         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8336
8337         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8338 }
8339 */
8340
8341 static struct hda_verb alc883_mitac_verbs[] = {
8342         /* HP */
8343         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8344         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8345         /* Subwoofer */
8346         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8347         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8348
8349         /* enable unsolicited event */
8350         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8351         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8352
8353         { } /* end */
8354 };
8355
8356 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8357         /* HP */
8358         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8359         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8360         /* Int speaker */
8361         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8362
8363         /* enable unsolicited event */
8364         /*
8365         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8366         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8367         */
8368
8369         { } /* end */
8370 };
8371
8372 static struct hda_verb alc883_clevo_m720_verbs[] = {
8373         /* HP */
8374         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8375         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8376         /* Int speaker */
8377         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8378         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8379
8380         /* enable unsolicited event */
8381         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8382         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8383
8384         { } /* end */
8385 };
8386
8387 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8388         /* HP */
8389         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8390         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8391         /* Subwoofer */
8392         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8393         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8394
8395         /* enable unsolicited event */
8396         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8397
8398         { } /* end */
8399 };
8400
8401 static struct hda_verb alc883_targa_verbs[] = {
8402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8404
8405         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8406         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8407
8408 /* Connect Line-Out side jack (SPDIF) to Side */
8409         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8410         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8411         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8412 /* Connect Mic jack to CLFE */
8413         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8414         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8415         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8416 /* Connect Line-in jack to Surround */
8417         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8418         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8419         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8420 /* Connect HP out jack to Front */
8421         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8422         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8423         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8424
8425         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8426
8427         { } /* end */
8428 };
8429
8430 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8431         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8432         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8433         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8434         { } /* end */
8435 };
8436
8437 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8438         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8439         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8440         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8441         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8442         { } /* end */
8443 };
8444
8445 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8447         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8448         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8449         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8450         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8451         { } /* end */
8452 };
8453
8454 static struct hda_verb alc883_haier_w66_verbs[] = {
8455         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8456         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8457
8458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8459
8460         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8461         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8462         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8463         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8464         { } /* end */
8465 };
8466
8467 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8468         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8469         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8470         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8473         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8474         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8475         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8476         { } /* end */
8477 };
8478
8479 static struct hda_verb alc888_6st_dell_verbs[] = {
8480         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8481         { }
8482 };
8483
8484 static struct hda_verb alc883_vaiott_verbs[] = {
8485         /* HP */
8486         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8487         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8488
8489         /* enable unsolicited event */
8490         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8491
8492         { } /* end */
8493 };
8494
8495 static void alc888_3st_hp_setup(struct hda_codec *codec)
8496 {
8497         struct alc_spec *spec = codec->spec;
8498
8499         spec->autocfg.hp_pins[0] = 0x1b;
8500         spec->autocfg.speaker_pins[0] = 0x14;
8501         spec->autocfg.speaker_pins[1] = 0x16;
8502         spec->autocfg.speaker_pins[2] = 0x18;
8503 }
8504
8505 static struct hda_verb alc888_3st_hp_verbs[] = {
8506         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8507         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8508         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8509         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8510         { } /* end */
8511 };
8512
8513 /*
8514  * 2ch mode
8515  */
8516 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8517         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8518         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8519         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8520         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8521         { } /* end */
8522 };
8523
8524 /*
8525  * 4ch mode
8526  */
8527 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8528         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8529         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8530         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8531         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8532         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8533         { } /* end */
8534 };
8535
8536 /*
8537  * 6ch mode
8538  */
8539 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8540         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8541         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8542         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8543         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8544         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8545         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8546         { } /* end */
8547 };
8548
8549 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8550         { 2, alc888_3st_hp_2ch_init },
8551         { 4, alc888_3st_hp_4ch_init },
8552         { 6, alc888_3st_hp_6ch_init },
8553 };
8554
8555 /* toggle front-jack and RCA according to the hp-jack state */
8556 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8557 {
8558         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8559
8560         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8561                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8562         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8563                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8564 }
8565
8566 /* toggle RCA according to the front-jack state */
8567 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8568 {
8569         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8570
8571         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8572                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8573 }
8574
8575 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8576                                              unsigned int res)
8577 {
8578         if ((res >> 26) == ALC880_HP_EVENT)
8579                 alc888_lenovo_ms7195_front_automute(codec);
8580         if ((res >> 26) == ALC880_FRONT_EVENT)
8581                 alc888_lenovo_ms7195_rca_automute(codec);
8582 }
8583
8584 static struct hda_verb alc883_medion_md2_verbs[] = {
8585         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8586         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8587
8588         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8589
8590         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8591         { } /* end */
8592 };
8593
8594 /* toggle speaker-output according to the hp-jack state */
8595 static void alc883_medion_md2_setup(struct hda_codec *codec)
8596 {
8597         struct alc_spec *spec = codec->spec;
8598
8599         spec->autocfg.hp_pins[0] = 0x14;
8600         spec->autocfg.speaker_pins[0] = 0x15;
8601 }
8602
8603 /* toggle speaker-output according to the hp-jack state */
8604 #define alc883_targa_init_hook          alc882_targa_init_hook
8605 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8606
8607 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8608 {
8609         unsigned int present;
8610
8611         present = snd_hda_jack_detect(codec, 0x18);
8612         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8613                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8614 }
8615
8616 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8617 {
8618         struct alc_spec *spec = codec->spec;
8619
8620         spec->autocfg.hp_pins[0] = 0x15;
8621         spec->autocfg.speaker_pins[0] = 0x14;
8622 }
8623
8624 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8625 {
8626         alc_automute_amp(codec);
8627         alc883_clevo_m720_mic_automute(codec);
8628 }
8629
8630 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8631                                            unsigned int res)
8632 {
8633         switch (res >> 26) {
8634         case ALC880_MIC_EVENT:
8635                 alc883_clevo_m720_mic_automute(codec);
8636                 break;
8637         default:
8638                 alc_automute_amp_unsol_event(codec, res);
8639                 break;
8640         }
8641 }
8642
8643 /* toggle speaker-output according to the hp-jack state */
8644 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8645 {
8646         struct alc_spec *spec = codec->spec;
8647
8648         spec->autocfg.hp_pins[0] = 0x14;
8649         spec->autocfg.speaker_pins[0] = 0x15;
8650 }
8651
8652 static void alc883_haier_w66_setup(struct hda_codec *codec)
8653 {
8654         struct alc_spec *spec = codec->spec;
8655
8656         spec->autocfg.hp_pins[0] = 0x1b;
8657         spec->autocfg.speaker_pins[0] = 0x14;
8658 }
8659
8660 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8661 {
8662         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8663
8664         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8665                                  HDA_AMP_MUTE, bits);
8666 }
8667
8668 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8669 {
8670         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8671
8672         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8673                                  HDA_AMP_MUTE, bits);
8674         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8675                                  HDA_AMP_MUTE, bits);
8676 }
8677
8678 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8679                                            unsigned int res)
8680 {
8681         if ((res >> 26) == ALC880_HP_EVENT)
8682                 alc883_lenovo_101e_all_automute(codec);
8683         if ((res >> 26) == ALC880_FRONT_EVENT)
8684                 alc883_lenovo_101e_ispeaker_automute(codec);
8685 }
8686
8687 /* toggle speaker-output according to the hp-jack state */
8688 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8689 {
8690         struct alc_spec *spec = codec->spec;
8691
8692         spec->autocfg.hp_pins[0] = 0x14;
8693         spec->autocfg.speaker_pins[0] = 0x15;
8694         spec->autocfg.speaker_pins[1] = 0x16;
8695 }
8696
8697 static struct hda_verb alc883_acer_eapd_verbs[] = {
8698         /* HP Pin: output 0 (0x0c) */
8699         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8700         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8701         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8702         /* Front Pin: output 0 (0x0c) */
8703         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8704         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8705         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8706         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8707         /* eanable EAPD on medion laptop */
8708         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8709         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8710         /* enable unsolicited event */
8711         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8712         { }
8713 };
8714
8715 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8716         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8717         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8718         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8719         { } /* end */
8720 };
8721
8722 static void alc888_6st_dell_setup(struct hda_codec *codec)
8723 {
8724         struct alc_spec *spec = codec->spec;
8725
8726         spec->autocfg.hp_pins[0] = 0x1b;
8727         spec->autocfg.speaker_pins[0] = 0x14;
8728         spec->autocfg.speaker_pins[1] = 0x15;
8729         spec->autocfg.speaker_pins[2] = 0x16;
8730         spec->autocfg.speaker_pins[3] = 0x17;
8731 }
8732
8733 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8734 {
8735         struct alc_spec *spec = codec->spec;
8736
8737         spec->autocfg.hp_pins[0] = 0x1b;
8738         spec->autocfg.speaker_pins[0] = 0x14;
8739         spec->autocfg.speaker_pins[1] = 0x15;
8740         spec->autocfg.speaker_pins[2] = 0x16;
8741         spec->autocfg.speaker_pins[3] = 0x17;
8742         spec->autocfg.speaker_pins[4] = 0x1a;
8743 }
8744
8745 static void alc883_vaiott_setup(struct hda_codec *codec)
8746 {
8747         struct alc_spec *spec = codec->spec;
8748
8749         spec->autocfg.hp_pins[0] = 0x15;
8750         spec->autocfg.speaker_pins[0] = 0x14;
8751         spec->autocfg.speaker_pins[1] = 0x17;
8752 }
8753
8754 static struct hda_verb alc888_asus_m90v_verbs[] = {
8755         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8756         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8757         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8758         /* enable unsolicited event */
8759         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8760         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8761         { } /* end */
8762 };
8763
8764 static void alc883_mode2_setup(struct hda_codec *codec)
8765 {
8766         struct alc_spec *spec = codec->spec;
8767
8768         spec->autocfg.hp_pins[0] = 0x1b;
8769         spec->autocfg.speaker_pins[0] = 0x14;
8770         spec->autocfg.speaker_pins[1] = 0x15;
8771         spec->autocfg.speaker_pins[2] = 0x16;
8772         spec->ext_mic.pin = 0x18;
8773         spec->int_mic.pin = 0x19;
8774         spec->ext_mic.mux_idx = 0;
8775         spec->int_mic.mux_idx = 1;
8776         spec->auto_mic = 1;
8777 }
8778
8779 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8780         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8781         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8782         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8783         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8784         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8785         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8786         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8787         /* enable unsolicited event */
8788         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8789         { } /* end */
8790 };
8791
8792 static void alc883_eee1601_inithook(struct hda_codec *codec)
8793 {
8794         struct alc_spec *spec = codec->spec;
8795
8796         spec->autocfg.hp_pins[0] = 0x14;
8797         spec->autocfg.speaker_pins[0] = 0x1b;
8798         alc_automute_pin(codec);
8799 }
8800
8801 static struct hda_verb alc889A_mb31_verbs[] = {
8802         /* Init rear pin (used as headphone output) */
8803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8804         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8805         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8806         /* Init line pin (used as output in 4ch and 6ch mode) */
8807         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8808         /* Init line 2 pin (used as headphone out by default) */
8809         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8810         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8811         { } /* end */
8812 };
8813
8814 /* Mute speakers according to the headphone jack state */
8815 static void alc889A_mb31_automute(struct hda_codec *codec)
8816 {
8817         unsigned int present;
8818
8819         /* Mute only in 2ch or 4ch mode */
8820         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8821             == 0x00) {
8822                 present = snd_hda_jack_detect(codec, 0x15);
8823                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8824                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8825                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8826                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8827         }
8828 }
8829
8830 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8831 {
8832         if ((res >> 26) == ALC880_HP_EVENT)
8833                 alc889A_mb31_automute(codec);
8834 }
8835
8836
8837 #ifdef CONFIG_SND_HDA_POWER_SAVE
8838 #define alc882_loopbacks        alc880_loopbacks
8839 #endif
8840
8841 /* pcm configuration: identical with ALC880 */
8842 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8843 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8844 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8845 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8846
8847 static hda_nid_t alc883_slave_dig_outs[] = {
8848         ALC1200_DIGOUT_NID, 0,
8849 };
8850
8851 static hda_nid_t alc1200_slave_dig_outs[] = {
8852         ALC883_DIGOUT_NID, 0,
8853 };
8854
8855 /*
8856  * configuration and preset
8857  */
8858 static const char *alc882_models[ALC882_MODEL_LAST] = {
8859         [ALC882_3ST_DIG]        = "3stack-dig",
8860         [ALC882_6ST_DIG]        = "6stack-dig",
8861         [ALC882_ARIMA]          = "arima",
8862         [ALC882_W2JC]           = "w2jc",
8863         [ALC882_TARGA]          = "targa",
8864         [ALC882_ASUS_A7J]       = "asus-a7j",
8865         [ALC882_ASUS_A7M]       = "asus-a7m",
8866         [ALC885_MACPRO]         = "macpro",
8867         [ALC885_MB5]            = "mb5",
8868         [ALC885_MBP3]           = "mbp3",
8869         [ALC885_IMAC24]         = "imac24",
8870         [ALC885_IMAC91]         = "imac91",
8871         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8872         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8873         [ALC883_3ST_6ch]        = "3stack-6ch",
8874         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8875         [ALC883_TARGA_DIG]      = "targa-dig",
8876         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8877         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8878         [ALC883_ACER]           = "acer",
8879         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8880         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8881         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8882         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8883         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
8884         [ALC883_MEDION]         = "medion",
8885         [ALC883_MEDION_MD2]     = "medion-md2",
8886         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8887         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8888         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8889         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8890         [ALC888_LENOVO_SKY] = "lenovo-sky",
8891         [ALC883_HAIER_W66]      = "haier-w66",
8892         [ALC888_3ST_HP]         = "3stack-hp",
8893         [ALC888_6ST_DELL]       = "6stack-dell",
8894         [ALC883_MITAC]          = "mitac",
8895         [ALC883_CLEVO_M540R]    = "clevo-m540r",
8896         [ALC883_CLEVO_M720]     = "clevo-m720",
8897         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8898         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8899         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8900         [ALC889A_INTEL]         = "intel-alc889a",
8901         [ALC889_INTEL]          = "intel-x58",
8902         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8903         [ALC889A_MB31]          = "mb31",
8904         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8905         [ALC882_AUTO]           = "auto",
8906 };
8907
8908 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8909         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8910
8911         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8912         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8913         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8914         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8915         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8916         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8917         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8918                 ALC888_ACER_ASPIRE_4930G),
8919         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8920                 ALC888_ACER_ASPIRE_4930G),
8921         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8922                 ALC888_ACER_ASPIRE_8930G),
8923         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8924                 ALC888_ACER_ASPIRE_8930G),
8925         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8926         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8927         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8928                 ALC888_ACER_ASPIRE_6530G),
8929         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8930                 ALC888_ACER_ASPIRE_6530G),
8931         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
8932                 ALC888_ACER_ASPIRE_7730G),
8933         /* default Acer -- disabled as it causes more problems.
8934          *    model=auto should work fine now
8935          */
8936         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8937
8938         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8939
8940         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8941         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8942         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8943         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8944         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8945         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8946
8947         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8948         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8949         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8950         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8951         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8952         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8953         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8954         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8955         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8956         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8957         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8958
8959         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8960         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8961         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8962         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8963         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8964         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8965         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8966         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8967         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8968
8969         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8970         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8971         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8972         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8973         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
8974         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8975         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8976         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8977         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8978         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8979         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8980         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8981         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8982         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8983         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8984         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8985         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8986         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8987         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8988         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8989         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8990         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8991         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8992         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8993         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8994         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8995         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8996         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8997         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8998
8999         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9000         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9001         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9002         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9003         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9004         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9005         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9006         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9007         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9008                       ALC883_FUJITSU_PI2515),
9009         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9010                 ALC888_FUJITSU_XA3530),
9011         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9012         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9013         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9014         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9015         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9016         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9017         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9018         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9019         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9020
9021         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9022         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9023         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9024         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9025         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9026         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9027         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
9028
9029         {}
9030 };
9031
9032 /* codec SSID table for Intel Mac */
9033 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9034         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9035         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9036         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9037         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9038         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9039         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9040         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9041         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9042         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9043         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9044         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9045         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9046         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9047          * so apparently no perfect solution yet
9048          */
9049         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9050         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9051         {} /* terminator */
9052 };
9053
9054 static struct alc_config_preset alc882_presets[] = {
9055         [ALC882_3ST_DIG] = {
9056                 .mixers = { alc882_base_mixer },
9057                 .init_verbs = { alc882_base_init_verbs,
9058                                 alc882_adc1_init_verbs },
9059                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9060                 .dac_nids = alc882_dac_nids,
9061                 .dig_out_nid = ALC882_DIGOUT_NID,
9062                 .dig_in_nid = ALC882_DIGIN_NID,
9063                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9064                 .channel_mode = alc882_ch_modes,
9065                 .need_dac_fix = 1,
9066                 .input_mux = &alc882_capture_source,
9067         },
9068         [ALC882_6ST_DIG] = {
9069                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9070                 .init_verbs = { alc882_base_init_verbs,
9071                                 alc882_adc1_init_verbs },
9072                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9073                 .dac_nids = alc882_dac_nids,
9074                 .dig_out_nid = ALC882_DIGOUT_NID,
9075                 .dig_in_nid = ALC882_DIGIN_NID,
9076                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9077                 .channel_mode = alc882_sixstack_modes,
9078                 .input_mux = &alc882_capture_source,
9079         },
9080         [ALC882_ARIMA] = {
9081                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9082                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9083                                 alc882_eapd_verbs },
9084                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9085                 .dac_nids = alc882_dac_nids,
9086                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9087                 .channel_mode = alc882_sixstack_modes,
9088                 .input_mux = &alc882_capture_source,
9089         },
9090         [ALC882_W2JC] = {
9091                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9092                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9093                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9094                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9095                 .dac_nids = alc882_dac_nids,
9096                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9097                 .channel_mode = alc880_threestack_modes,
9098                 .need_dac_fix = 1,
9099                 .input_mux = &alc882_capture_source,
9100                 .dig_out_nid = ALC882_DIGOUT_NID,
9101         },
9102         [ALC885_MBP3] = {
9103                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9104                 .init_verbs = { alc885_mbp3_init_verbs,
9105                                 alc880_gpio1_init_verbs },
9106                 .num_dacs = 2,
9107                 .dac_nids = alc882_dac_nids,
9108                 .hp_nid = 0x04,
9109                 .channel_mode = alc885_mbp_4ch_modes,
9110                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9111                 .input_mux = &alc882_capture_source,
9112                 .dig_out_nid = ALC882_DIGOUT_NID,
9113                 .dig_in_nid = ALC882_DIGIN_NID,
9114                 .unsol_event = alc_automute_amp_unsol_event,
9115                 .setup = alc885_mbp3_setup,
9116                 .init_hook = alc_automute_amp,
9117         },
9118         [ALC885_MB5] = {
9119                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9120                 .init_verbs = { alc885_mb5_init_verbs,
9121                                 alc880_gpio1_init_verbs },
9122                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9123                 .dac_nids = alc882_dac_nids,
9124                 .channel_mode = alc885_mb5_6ch_modes,
9125                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9126                 .input_mux = &mb5_capture_source,
9127                 .dig_out_nid = ALC882_DIGOUT_NID,
9128                 .dig_in_nid = ALC882_DIGIN_NID,
9129         },
9130         [ALC885_MACPRO] = {
9131                 .mixers = { alc882_macpro_mixer },
9132                 .init_verbs = { alc882_macpro_init_verbs },
9133                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9134                 .dac_nids = alc882_dac_nids,
9135                 .dig_out_nid = ALC882_DIGOUT_NID,
9136                 .dig_in_nid = ALC882_DIGIN_NID,
9137                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9138                 .channel_mode = alc882_ch_modes,
9139                 .input_mux = &alc882_capture_source,
9140                 .init_hook = alc885_macpro_init_hook,
9141         },
9142         [ALC885_IMAC24] = {
9143                 .mixers = { alc885_imac24_mixer },
9144                 .init_verbs = { alc885_imac24_init_verbs },
9145                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9146                 .dac_nids = alc882_dac_nids,
9147                 .dig_out_nid = ALC882_DIGOUT_NID,
9148                 .dig_in_nid = ALC882_DIGIN_NID,
9149                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9150                 .channel_mode = alc882_ch_modes,
9151                 .input_mux = &alc882_capture_source,
9152                 .unsol_event = alc_automute_amp_unsol_event,
9153                 .setup = alc885_imac24_setup,
9154                 .init_hook = alc885_imac24_init_hook,
9155         },
9156         [ALC885_IMAC91] = {
9157                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9158                 .init_verbs = { alc885_imac91_init_verbs,
9159                                 alc880_gpio1_init_verbs },
9160                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9161                 .dac_nids = alc882_dac_nids,
9162                 .channel_mode = alc885_mbp_4ch_modes,
9163                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9164                 .input_mux = &alc882_capture_source,
9165                 .dig_out_nid = ALC882_DIGOUT_NID,
9166                 .dig_in_nid = ALC882_DIGIN_NID,
9167                 .unsol_event = alc885_imac91_unsol_event,
9168                 .init_hook = alc885_imac91_automute,
9169         },
9170         [ALC882_TARGA] = {
9171                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9172                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9173                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9174                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9175                 .dac_nids = alc882_dac_nids,
9176                 .dig_out_nid = ALC882_DIGOUT_NID,
9177                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9178                 .adc_nids = alc882_adc_nids,
9179                 .capsrc_nids = alc882_capsrc_nids,
9180                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9181                 .channel_mode = alc882_3ST_6ch_modes,
9182                 .need_dac_fix = 1,
9183                 .input_mux = &alc882_capture_source,
9184                 .unsol_event = alc882_targa_unsol_event,
9185                 .setup = alc882_targa_setup,
9186                 .init_hook = alc882_targa_automute,
9187         },
9188         [ALC882_ASUS_A7J] = {
9189                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9190                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9191                                 alc882_asus_a7j_verbs},
9192                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9193                 .dac_nids = alc882_dac_nids,
9194                 .dig_out_nid = ALC882_DIGOUT_NID,
9195                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9196                 .adc_nids = alc882_adc_nids,
9197                 .capsrc_nids = alc882_capsrc_nids,
9198                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9199                 .channel_mode = alc882_3ST_6ch_modes,
9200                 .need_dac_fix = 1,
9201                 .input_mux = &alc882_capture_source,
9202         },
9203         [ALC882_ASUS_A7M] = {
9204                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9205                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9206                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9207                                 alc882_asus_a7m_verbs },
9208                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9209                 .dac_nids = alc882_dac_nids,
9210                 .dig_out_nid = ALC882_DIGOUT_NID,
9211                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9212                 .channel_mode = alc880_threestack_modes,
9213                 .need_dac_fix = 1,
9214                 .input_mux = &alc882_capture_source,
9215         },
9216         [ALC883_3ST_2ch_DIG] = {
9217                 .mixers = { alc883_3ST_2ch_mixer },
9218                 .init_verbs = { alc883_init_verbs },
9219                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9220                 .dac_nids = alc883_dac_nids,
9221                 .dig_out_nid = ALC883_DIGOUT_NID,
9222                 .dig_in_nid = ALC883_DIGIN_NID,
9223                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9224                 .channel_mode = alc883_3ST_2ch_modes,
9225                 .input_mux = &alc883_capture_source,
9226         },
9227         [ALC883_3ST_6ch_DIG] = {
9228                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9229                 .init_verbs = { alc883_init_verbs },
9230                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9231                 .dac_nids = alc883_dac_nids,
9232                 .dig_out_nid = ALC883_DIGOUT_NID,
9233                 .dig_in_nid = ALC883_DIGIN_NID,
9234                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9235                 .channel_mode = alc883_3ST_6ch_modes,
9236                 .need_dac_fix = 1,
9237                 .input_mux = &alc883_capture_source,
9238         },
9239         [ALC883_3ST_6ch] = {
9240                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9241                 .init_verbs = { alc883_init_verbs },
9242                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9243                 .dac_nids = alc883_dac_nids,
9244                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9245                 .channel_mode = alc883_3ST_6ch_modes,
9246                 .need_dac_fix = 1,
9247                 .input_mux = &alc883_capture_source,
9248         },
9249         [ALC883_3ST_6ch_INTEL] = {
9250                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9251                 .init_verbs = { alc883_init_verbs },
9252                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9253                 .dac_nids = alc883_dac_nids,
9254                 .dig_out_nid = ALC883_DIGOUT_NID,
9255                 .dig_in_nid = ALC883_DIGIN_NID,
9256                 .slave_dig_outs = alc883_slave_dig_outs,
9257                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9258                 .channel_mode = alc883_3ST_6ch_intel_modes,
9259                 .need_dac_fix = 1,
9260                 .input_mux = &alc883_3stack_6ch_intel,
9261         },
9262         [ALC889A_INTEL] = {
9263                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9264                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9265                                 alc_hp15_unsol_verbs },
9266                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9267                 .dac_nids = alc883_dac_nids,
9268                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9269                 .adc_nids = alc889_adc_nids,
9270                 .dig_out_nid = ALC883_DIGOUT_NID,
9271                 .dig_in_nid = ALC883_DIGIN_NID,
9272                 .slave_dig_outs = alc883_slave_dig_outs,
9273                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9274                 .channel_mode = alc889_8ch_intel_modes,
9275                 .capsrc_nids = alc889_capsrc_nids,
9276                 .input_mux = &alc889_capture_source,
9277                 .setup = alc889_automute_setup,
9278                 .init_hook = alc_automute_amp,
9279                 .unsol_event = alc_automute_amp_unsol_event,
9280                 .need_dac_fix = 1,
9281         },
9282         [ALC889_INTEL] = {
9283                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9284                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9285                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9286                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9287                 .dac_nids = alc883_dac_nids,
9288                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9289                 .adc_nids = alc889_adc_nids,
9290                 .dig_out_nid = ALC883_DIGOUT_NID,
9291                 .dig_in_nid = ALC883_DIGIN_NID,
9292                 .slave_dig_outs = alc883_slave_dig_outs,
9293                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9294                 .channel_mode = alc889_8ch_intel_modes,
9295                 .capsrc_nids = alc889_capsrc_nids,
9296                 .input_mux = &alc889_capture_source,
9297                 .setup = alc889_automute_setup,
9298                 .init_hook = alc889_intel_init_hook,
9299                 .unsol_event = alc_automute_amp_unsol_event,
9300                 .need_dac_fix = 1,
9301         },
9302         [ALC883_6ST_DIG] = {
9303                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9304                 .init_verbs = { alc883_init_verbs },
9305                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9306                 .dac_nids = alc883_dac_nids,
9307                 .dig_out_nid = ALC883_DIGOUT_NID,
9308                 .dig_in_nid = ALC883_DIGIN_NID,
9309                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9310                 .channel_mode = alc883_sixstack_modes,
9311                 .input_mux = &alc883_capture_source,
9312         },
9313         [ALC883_TARGA_DIG] = {
9314                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9315                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9316                                 alc883_targa_verbs},
9317                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9318                 .dac_nids = alc883_dac_nids,
9319                 .dig_out_nid = ALC883_DIGOUT_NID,
9320                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9321                 .channel_mode = alc883_3ST_6ch_modes,
9322                 .need_dac_fix = 1,
9323                 .input_mux = &alc883_capture_source,
9324                 .unsol_event = alc883_targa_unsol_event,
9325                 .setup = alc882_targa_setup,
9326                 .init_hook = alc882_targa_automute,
9327         },
9328         [ALC883_TARGA_2ch_DIG] = {
9329                 .mixers = { alc883_targa_2ch_mixer},
9330                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9331                                 alc883_targa_verbs},
9332                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9333                 .dac_nids = alc883_dac_nids,
9334                 .adc_nids = alc883_adc_nids_alt,
9335                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9336                 .capsrc_nids = alc883_capsrc_nids,
9337                 .dig_out_nid = ALC883_DIGOUT_NID,
9338                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9339                 .channel_mode = alc883_3ST_2ch_modes,
9340                 .input_mux = &alc883_capture_source,
9341                 .unsol_event = alc883_targa_unsol_event,
9342                 .setup = alc882_targa_setup,
9343                 .init_hook = alc882_targa_automute,
9344         },
9345         [ALC883_TARGA_8ch_DIG] = {
9346                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9347                             alc883_chmode_mixer },
9348                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9349                                 alc883_targa_verbs },
9350                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9351                 .dac_nids = alc883_dac_nids,
9352                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9353                 .adc_nids = alc883_adc_nids_rev,
9354                 .capsrc_nids = alc883_capsrc_nids_rev,
9355                 .dig_out_nid = ALC883_DIGOUT_NID,
9356                 .dig_in_nid = ALC883_DIGIN_NID,
9357                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9358                 .channel_mode = alc883_4ST_8ch_modes,
9359                 .need_dac_fix = 1,
9360                 .input_mux = &alc883_capture_source,
9361                 .unsol_event = alc883_targa_unsol_event,
9362                 .setup = alc882_targa_setup,
9363                 .init_hook = alc882_targa_automute,
9364         },
9365         [ALC883_ACER] = {
9366                 .mixers = { alc883_base_mixer },
9367                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9368                  * and the headphone jack.  Turn this on and rely on the
9369                  * standard mute methods whenever the user wants to turn
9370                  * these outputs off.
9371                  */
9372                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9373                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9374                 .dac_nids = alc883_dac_nids,
9375                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9376                 .channel_mode = alc883_3ST_2ch_modes,
9377                 .input_mux = &alc883_capture_source,
9378         },
9379         [ALC883_ACER_ASPIRE] = {
9380                 .mixers = { alc883_acer_aspire_mixer },
9381                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9382                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9383                 .dac_nids = alc883_dac_nids,
9384                 .dig_out_nid = ALC883_DIGOUT_NID,
9385                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9386                 .channel_mode = alc883_3ST_2ch_modes,
9387                 .input_mux = &alc883_capture_source,
9388                 .unsol_event = alc_automute_amp_unsol_event,
9389                 .setup = alc883_acer_aspire_setup,
9390                 .init_hook = alc_automute_amp,
9391         },
9392         [ALC888_ACER_ASPIRE_4930G] = {
9393                 .mixers = { alc888_base_mixer,
9394                                 alc883_chmode_mixer },
9395                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9396                                 alc888_acer_aspire_4930g_verbs },
9397                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9398                 .dac_nids = alc883_dac_nids,
9399                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9400                 .adc_nids = alc883_adc_nids_rev,
9401                 .capsrc_nids = alc883_capsrc_nids_rev,
9402                 .dig_out_nid = ALC883_DIGOUT_NID,
9403                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9404                 .channel_mode = alc883_3ST_6ch_modes,
9405                 .need_dac_fix = 1,
9406                 .num_mux_defs =
9407                         ARRAY_SIZE(alc888_2_capture_sources),
9408                 .input_mux = alc888_2_capture_sources,
9409                 .unsol_event = alc_automute_amp_unsol_event,
9410                 .setup = alc888_acer_aspire_4930g_setup,
9411                 .init_hook = alc_automute_amp,
9412         },
9413         [ALC888_ACER_ASPIRE_6530G] = {
9414                 .mixers = { alc888_acer_aspire_6530_mixer },
9415                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9416                                 alc888_acer_aspire_6530g_verbs },
9417                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9418                 .dac_nids = alc883_dac_nids,
9419                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9420                 .adc_nids = alc883_adc_nids_rev,
9421                 .capsrc_nids = alc883_capsrc_nids_rev,
9422                 .dig_out_nid = ALC883_DIGOUT_NID,
9423                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9424                 .channel_mode = alc883_3ST_2ch_modes,
9425                 .num_mux_defs =
9426                         ARRAY_SIZE(alc888_2_capture_sources),
9427                 .input_mux = alc888_acer_aspire_6530_sources,
9428                 .unsol_event = alc_automute_amp_unsol_event,
9429                 .setup = alc888_acer_aspire_6530g_setup,
9430                 .init_hook = alc_automute_amp,
9431         },
9432         [ALC888_ACER_ASPIRE_8930G] = {
9433                 .mixers = { alc889_acer_aspire_8930g_mixer,
9434                                 alc883_chmode_mixer },
9435                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9436                                 alc889_acer_aspire_8930g_verbs,
9437                                 alc889_eapd_verbs},
9438                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9439                 .dac_nids = alc883_dac_nids,
9440                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9441                 .adc_nids = alc889_adc_nids,
9442                 .capsrc_nids = alc889_capsrc_nids,
9443                 .dig_out_nid = ALC883_DIGOUT_NID,
9444                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9445                 .channel_mode = alc883_3ST_6ch_modes,
9446                 .need_dac_fix = 1,
9447                 .const_channel_count = 6,
9448                 .num_mux_defs =
9449                         ARRAY_SIZE(alc889_capture_sources),
9450                 .input_mux = alc889_capture_sources,
9451                 .unsol_event = alc_automute_amp_unsol_event,
9452                 .setup = alc889_acer_aspire_8930g_setup,
9453                 .init_hook = alc_automute_amp,
9454 #ifdef CONFIG_SND_HDA_POWER_SAVE
9455                 .power_hook = alc889_power_eapd,
9456 #endif
9457         },
9458         [ALC888_ACER_ASPIRE_7730G] = {
9459                 .mixers = { alc883_3ST_6ch_mixer,
9460                                 alc883_chmode_mixer },
9461                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9462                                 alc888_acer_aspire_7730G_verbs },
9463                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9464                 .dac_nids = alc883_dac_nids,
9465                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9466                 .adc_nids = alc883_adc_nids_rev,
9467                 .capsrc_nids = alc883_capsrc_nids_rev,
9468                 .dig_out_nid = ALC883_DIGOUT_NID,
9469                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9470                 .channel_mode = alc883_3ST_6ch_modes,
9471                 .need_dac_fix = 1,
9472                 .const_channel_count = 6,
9473                 .input_mux = &alc883_capture_source,
9474                 .unsol_event = alc_automute_amp_unsol_event,
9475                 .setup = alc888_acer_aspire_6530g_setup,
9476                 .init_hook = alc_automute_amp,
9477         },
9478         [ALC883_MEDION] = {
9479                 .mixers = { alc883_fivestack_mixer,
9480                             alc883_chmode_mixer },
9481                 .init_verbs = { alc883_init_verbs,
9482                                 alc883_medion_eapd_verbs },
9483                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9484                 .dac_nids = alc883_dac_nids,
9485                 .adc_nids = alc883_adc_nids_alt,
9486                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9487                 .capsrc_nids = alc883_capsrc_nids,
9488                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9489                 .channel_mode = alc883_sixstack_modes,
9490                 .input_mux = &alc883_capture_source,
9491         },
9492         [ALC883_MEDION_MD2] = {
9493                 .mixers = { alc883_medion_md2_mixer},
9494                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9495                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9496                 .dac_nids = alc883_dac_nids,
9497                 .dig_out_nid = ALC883_DIGOUT_NID,
9498                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9499                 .channel_mode = alc883_3ST_2ch_modes,
9500                 .input_mux = &alc883_capture_source,
9501                 .unsol_event = alc_automute_amp_unsol_event,
9502                 .setup = alc883_medion_md2_setup,
9503                 .init_hook = alc_automute_amp,
9504         },
9505         [ALC883_LAPTOP_EAPD] = {
9506                 .mixers = { alc883_base_mixer },
9507                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9508                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9509                 .dac_nids = alc883_dac_nids,
9510                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9511                 .channel_mode = alc883_3ST_2ch_modes,
9512                 .input_mux = &alc883_capture_source,
9513         },
9514         [ALC883_CLEVO_M540R] = {
9515                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9516                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9517                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9518                 .dac_nids = alc883_dac_nids,
9519                 .dig_out_nid = ALC883_DIGOUT_NID,
9520                 .dig_in_nid = ALC883_DIGIN_NID,
9521                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9522                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9523                 .need_dac_fix = 1,
9524                 .input_mux = &alc883_capture_source,
9525                 /* This machine has the hardware HP auto-muting, thus
9526                  * we need no software mute via unsol event
9527                  */
9528         },
9529         [ALC883_CLEVO_M720] = {
9530                 .mixers = { alc883_clevo_m720_mixer },
9531                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9532                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9533                 .dac_nids = alc883_dac_nids,
9534                 .dig_out_nid = ALC883_DIGOUT_NID,
9535                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9536                 .channel_mode = alc883_3ST_2ch_modes,
9537                 .input_mux = &alc883_capture_source,
9538                 .unsol_event = alc883_clevo_m720_unsol_event,
9539                 .setup = alc883_clevo_m720_setup,
9540                 .init_hook = alc883_clevo_m720_init_hook,
9541         },
9542         [ALC883_LENOVO_101E_2ch] = {
9543                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9544                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9545                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9546                 .dac_nids = alc883_dac_nids,
9547                 .adc_nids = alc883_adc_nids_alt,
9548                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9549                 .capsrc_nids = alc883_capsrc_nids,
9550                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9551                 .channel_mode = alc883_3ST_2ch_modes,
9552                 .input_mux = &alc883_lenovo_101e_capture_source,
9553                 .unsol_event = alc883_lenovo_101e_unsol_event,
9554                 .init_hook = alc883_lenovo_101e_all_automute,
9555         },
9556         [ALC883_LENOVO_NB0763] = {
9557                 .mixers = { alc883_lenovo_nb0763_mixer },
9558                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9559                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9560                 .dac_nids = alc883_dac_nids,
9561                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9562                 .channel_mode = alc883_3ST_2ch_modes,
9563                 .need_dac_fix = 1,
9564                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9565                 .unsol_event = alc_automute_amp_unsol_event,
9566                 .setup = alc883_medion_md2_setup,
9567                 .init_hook = alc_automute_amp,
9568         },
9569         [ALC888_LENOVO_MS7195_DIG] = {
9570                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9571                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9572                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9573                 .dac_nids = alc883_dac_nids,
9574                 .dig_out_nid = ALC883_DIGOUT_NID,
9575                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9576                 .channel_mode = alc883_3ST_6ch_modes,
9577                 .need_dac_fix = 1,
9578                 .input_mux = &alc883_capture_source,
9579                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9580                 .init_hook = alc888_lenovo_ms7195_front_automute,
9581         },
9582         [ALC883_HAIER_W66] = {
9583                 .mixers = { alc883_targa_2ch_mixer},
9584                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9585                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9586                 .dac_nids = alc883_dac_nids,
9587                 .dig_out_nid = ALC883_DIGOUT_NID,
9588                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9589                 .channel_mode = alc883_3ST_2ch_modes,
9590                 .input_mux = &alc883_capture_source,
9591                 .unsol_event = alc_automute_amp_unsol_event,
9592                 .setup = alc883_haier_w66_setup,
9593                 .init_hook = alc_automute_amp,
9594         },
9595         [ALC888_3ST_HP] = {
9596                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9597                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9598                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9599                 .dac_nids = alc883_dac_nids,
9600                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9601                 .channel_mode = alc888_3st_hp_modes,
9602                 .need_dac_fix = 1,
9603                 .input_mux = &alc883_capture_source,
9604                 .unsol_event = alc_automute_amp_unsol_event,
9605                 .setup = alc888_3st_hp_setup,
9606                 .init_hook = alc_automute_amp,
9607         },
9608         [ALC888_6ST_DELL] = {
9609                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9610                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9611                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9612                 .dac_nids = alc883_dac_nids,
9613                 .dig_out_nid = ALC883_DIGOUT_NID,
9614                 .dig_in_nid = ALC883_DIGIN_NID,
9615                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9616                 .channel_mode = alc883_sixstack_modes,
9617                 .input_mux = &alc883_capture_source,
9618                 .unsol_event = alc_automute_amp_unsol_event,
9619                 .setup = alc888_6st_dell_setup,
9620                 .init_hook = alc_automute_amp,
9621         },
9622         [ALC883_MITAC] = {
9623                 .mixers = { alc883_mitac_mixer },
9624                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9625                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9626                 .dac_nids = alc883_dac_nids,
9627                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9628                 .channel_mode = alc883_3ST_2ch_modes,
9629                 .input_mux = &alc883_capture_source,
9630                 .unsol_event = alc_automute_amp_unsol_event,
9631                 .setup = alc883_mitac_setup,
9632                 .init_hook = alc_automute_amp,
9633         },
9634         [ALC883_FUJITSU_PI2515] = {
9635                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9636                 .init_verbs = { alc883_init_verbs,
9637                                 alc883_2ch_fujitsu_pi2515_verbs},
9638                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9639                 .dac_nids = alc883_dac_nids,
9640                 .dig_out_nid = ALC883_DIGOUT_NID,
9641                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9642                 .channel_mode = alc883_3ST_2ch_modes,
9643                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9644                 .unsol_event = alc_automute_amp_unsol_event,
9645                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9646                 .init_hook = alc_automute_amp,
9647         },
9648         [ALC888_FUJITSU_XA3530] = {
9649                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9650                 .init_verbs = { alc883_init_verbs,
9651                         alc888_fujitsu_xa3530_verbs },
9652                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9653                 .dac_nids = alc883_dac_nids,
9654                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9655                 .adc_nids = alc883_adc_nids_rev,
9656                 .capsrc_nids = alc883_capsrc_nids_rev,
9657                 .dig_out_nid = ALC883_DIGOUT_NID,
9658                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9659                 .channel_mode = alc888_4ST_8ch_intel_modes,
9660                 .num_mux_defs =
9661                         ARRAY_SIZE(alc888_2_capture_sources),
9662                 .input_mux = alc888_2_capture_sources,
9663                 .unsol_event = alc_automute_amp_unsol_event,
9664                 .setup = alc888_fujitsu_xa3530_setup,
9665                 .init_hook = alc_automute_amp,
9666         },
9667         [ALC888_LENOVO_SKY] = {
9668                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9669                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9670                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9671                 .dac_nids = alc883_dac_nids,
9672                 .dig_out_nid = ALC883_DIGOUT_NID,
9673                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9674                 .channel_mode = alc883_sixstack_modes,
9675                 .need_dac_fix = 1,
9676                 .input_mux = &alc883_lenovo_sky_capture_source,
9677                 .unsol_event = alc_automute_amp_unsol_event,
9678                 .setup = alc888_lenovo_sky_setup,
9679                 .init_hook = alc_automute_amp,
9680         },
9681         [ALC888_ASUS_M90V] = {
9682                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9683                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9684                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9685                 .dac_nids = alc883_dac_nids,
9686                 .dig_out_nid = ALC883_DIGOUT_NID,
9687                 .dig_in_nid = ALC883_DIGIN_NID,
9688                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9689                 .channel_mode = alc883_3ST_6ch_modes,
9690                 .need_dac_fix = 1,
9691                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9692                 .unsol_event = alc_sku_unsol_event,
9693                 .setup = alc883_mode2_setup,
9694                 .init_hook = alc_inithook,
9695         },
9696         [ALC888_ASUS_EEE1601] = {
9697                 .mixers = { alc883_asus_eee1601_mixer },
9698                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9699                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9700                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9701                 .dac_nids = alc883_dac_nids,
9702                 .dig_out_nid = ALC883_DIGOUT_NID,
9703                 .dig_in_nid = ALC883_DIGIN_NID,
9704                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9705                 .channel_mode = alc883_3ST_2ch_modes,
9706                 .need_dac_fix = 1,
9707                 .input_mux = &alc883_asus_eee1601_capture_source,
9708                 .unsol_event = alc_sku_unsol_event,
9709                 .init_hook = alc883_eee1601_inithook,
9710         },
9711         [ALC1200_ASUS_P5Q] = {
9712                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9713                 .init_verbs = { alc883_init_verbs },
9714                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9715                 .dac_nids = alc883_dac_nids,
9716                 .dig_out_nid = ALC1200_DIGOUT_NID,
9717                 .dig_in_nid = ALC883_DIGIN_NID,
9718                 .slave_dig_outs = alc1200_slave_dig_outs,
9719                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9720                 .channel_mode = alc883_sixstack_modes,
9721                 .input_mux = &alc883_capture_source,
9722         },
9723         [ALC889A_MB31] = {
9724                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9725                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9726                         alc880_gpio1_init_verbs },
9727                 .adc_nids = alc883_adc_nids,
9728                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9729                 .capsrc_nids = alc883_capsrc_nids,
9730                 .dac_nids = alc883_dac_nids,
9731                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9732                 .channel_mode = alc889A_mb31_6ch_modes,
9733                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9734                 .input_mux = &alc889A_mb31_capture_source,
9735                 .dig_out_nid = ALC883_DIGOUT_NID,
9736                 .unsol_event = alc889A_mb31_unsol_event,
9737                 .init_hook = alc889A_mb31_automute,
9738         },
9739         [ALC883_SONY_VAIO_TT] = {
9740                 .mixers = { alc883_vaiott_mixer },
9741                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9742                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9743                 .dac_nids = alc883_dac_nids,
9744                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9745                 .channel_mode = alc883_3ST_2ch_modes,
9746                 .input_mux = &alc883_capture_source,
9747                 .unsol_event = alc_automute_amp_unsol_event,
9748                 .setup = alc883_vaiott_setup,
9749                 .init_hook = alc_automute_amp,
9750         },
9751 };
9752
9753
9754 /*
9755  * Pin config fixes
9756  */
9757 enum {
9758         PINFIX_ABIT_AW9D_MAX
9759 };
9760
9761 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9762         { 0x15, 0x01080104 }, /* side */
9763         { 0x16, 0x01011012 }, /* rear */
9764         { 0x17, 0x01016011 }, /* clfe */
9765         { }
9766 };
9767
9768 static const struct alc_fixup alc882_fixups[] = {
9769         [PINFIX_ABIT_AW9D_MAX] = {
9770                 .pins = alc882_abit_aw9d_pinfix
9771         },
9772 };
9773
9774 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9775         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9776         {}
9777 };
9778
9779 /*
9780  * BIOS auto configuration
9781  */
9782 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9783                                                 const struct auto_pin_cfg *cfg)
9784 {
9785         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9786 }
9787
9788 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9789                                               hda_nid_t nid, int pin_type,
9790                                               int dac_idx)
9791 {
9792         /* set as output */
9793         struct alc_spec *spec = codec->spec;
9794         int idx;
9795
9796         alc_set_pin_output(codec, nid, pin_type);
9797         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9798                 idx = 4;
9799         else
9800                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9801         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9802
9803 }
9804
9805 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9806 {
9807         struct alc_spec *spec = codec->spec;
9808         int i;
9809
9810         for (i = 0; i <= HDA_SIDE; i++) {
9811                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9812                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9813                 if (nid)
9814                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9815                                                           i);
9816         }
9817 }
9818
9819 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9820 {
9821         struct alc_spec *spec = codec->spec;
9822         hda_nid_t pin;
9823
9824         pin = spec->autocfg.hp_pins[0];
9825         if (pin) /* connect to front */
9826                 /* use dac 0 */
9827                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9828         pin = spec->autocfg.speaker_pins[0];
9829         if (pin)
9830                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9831 }
9832
9833 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9834 {
9835         struct alc_spec *spec = codec->spec;
9836         int i;
9837
9838         for (i = 0; i < AUTO_PIN_LAST; i++) {
9839                 hda_nid_t nid = spec->autocfg.input_pins[i];
9840                 if (!nid)
9841                         continue;
9842                 alc_set_input_pin(codec, nid, i);
9843                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9844                         snd_hda_codec_write(codec, nid, 0,
9845                                             AC_VERB_SET_AMP_GAIN_MUTE,
9846                                             AMP_OUT_MUTE);
9847         }
9848 }
9849
9850 static void alc882_auto_init_input_src(struct hda_codec *codec)
9851 {
9852         struct alc_spec *spec = codec->spec;
9853         int c;
9854
9855         for (c = 0; c < spec->num_adc_nids; c++) {
9856                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9857                 hda_nid_t nid = spec->capsrc_nids[c];
9858                 unsigned int mux_idx;
9859                 const struct hda_input_mux *imux;
9860                 int conns, mute, idx, item;
9861
9862                 conns = snd_hda_get_connections(codec, nid, conn_list,
9863                                                 ARRAY_SIZE(conn_list));
9864                 if (conns < 0)
9865                         continue;
9866                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9867                 imux = &spec->input_mux[mux_idx];
9868                 for (idx = 0; idx < conns; idx++) {
9869                         /* if the current connection is the selected one,
9870                          * unmute it as default - otherwise mute it
9871                          */
9872                         mute = AMP_IN_MUTE(idx);
9873                         for (item = 0; item < imux->num_items; item++) {
9874                                 if (imux->items[item].index == idx) {
9875                                         if (spec->cur_mux[c] == item)
9876                                                 mute = AMP_IN_UNMUTE(idx);
9877                                         break;
9878                                 }
9879                         }
9880                         /* check if we have a selector or mixer
9881                          * we could check for the widget type instead, but
9882                          * just check for Amp-In presence (in case of mixer
9883                          * without amp-in there is something wrong, this
9884                          * function shouldn't be used or capsrc nid is wrong)
9885                          */
9886                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9887                                 snd_hda_codec_write(codec, nid, 0,
9888                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9889                                                     mute);
9890                         else if (mute != AMP_IN_MUTE(idx))
9891                                 snd_hda_codec_write(codec, nid, 0,
9892                                                     AC_VERB_SET_CONNECT_SEL,
9893                                                     idx);
9894                 }
9895         }
9896 }
9897
9898 /* add mic boosts if needed */
9899 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9900 {
9901         struct alc_spec *spec = codec->spec;
9902         int err;
9903         hda_nid_t nid;
9904
9905         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9906         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9907                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9908                                   "Mic Boost",
9909                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9910                 if (err < 0)
9911                         return err;
9912         }
9913         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9914         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9915                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9916                                   "Front Mic Boost",
9917                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9918                 if (err < 0)
9919                         return err;
9920         }
9921         return 0;
9922 }
9923
9924 /* almost identical with ALC880 parser... */
9925 static int alc882_parse_auto_config(struct hda_codec *codec)
9926 {
9927         struct alc_spec *spec = codec->spec;
9928         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
9929         int i, err;
9930
9931         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9932                                            alc882_ignore);
9933         if (err < 0)
9934                 return err;
9935         if (!spec->autocfg.line_outs)
9936                 return 0; /* can't find valid BIOS pin config */
9937
9938         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
9939         if (err < 0)
9940                 return err;
9941         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
9942         if (err < 0)
9943                 return err;
9944         err = alc880_auto_create_extra_out(spec,
9945                                            spec->autocfg.speaker_pins[0],
9946                                            "Speaker");
9947         if (err < 0)
9948                 return err;
9949         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9950                                            "Headphone");
9951         if (err < 0)
9952                 return err;
9953         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
9954         if (err < 0)
9955                 return err;
9956
9957         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9958
9959         /* check multiple SPDIF-out (for recent codecs) */
9960         for (i = 0; i < spec->autocfg.dig_outs; i++) {
9961                 hda_nid_t dig_nid;
9962                 err = snd_hda_get_connections(codec,
9963                                               spec->autocfg.dig_out_pins[i],
9964                                               &dig_nid, 1);
9965                 if (err < 0)
9966                         continue;
9967                 if (!i)
9968                         spec->multiout.dig_out_nid = dig_nid;
9969                 else {
9970                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
9971                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
9972                                 break;
9973                         spec->slave_dig_outs[i - 1] = dig_nid;
9974                 }
9975         }
9976         if (spec->autocfg.dig_in_pin)
9977                 spec->dig_in_nid = ALC880_DIGIN_NID;
9978
9979         if (spec->kctls.list)
9980                 add_mixer(spec, spec->kctls.list);
9981
9982         add_verb(spec, alc883_auto_init_verbs);
9983         /* if ADC 0x07 is available, initialize it, too */
9984         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
9985                 add_verb(spec, alc882_adc1_init_verbs);
9986
9987         spec->num_mux_defs = 1;
9988         spec->input_mux = &spec->private_imux[0];
9989
9990         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
9991
9992         err = alc_auto_add_mic_boost(codec);
9993         if (err < 0)
9994                 return err;
9995
9996         return 1; /* config found */
9997 }
9998
9999 /* additional initialization for auto-configuration model */
10000 static void alc882_auto_init(struct hda_codec *codec)
10001 {
10002         struct alc_spec *spec = codec->spec;
10003         alc882_auto_init_multi_out(codec);
10004         alc882_auto_init_hp_out(codec);
10005         alc882_auto_init_analog_input(codec);
10006         alc882_auto_init_input_src(codec);
10007         if (spec->unsol_event)
10008                 alc_inithook(codec);
10009 }
10010
10011 static int patch_alc882(struct hda_codec *codec)
10012 {
10013         struct alc_spec *spec;
10014         int err, board_config;
10015
10016         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10017         if (spec == NULL)
10018                 return -ENOMEM;
10019
10020         codec->spec = spec;
10021
10022         switch (codec->vendor_id) {
10023         case 0x10ec0882:
10024         case 0x10ec0885:
10025                 break;
10026         default:
10027                 /* ALC883 and variants */
10028                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10029                 break;
10030         }
10031
10032         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10033                                                   alc882_models,
10034                                                   alc882_cfg_tbl);
10035
10036         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10037                 board_config = snd_hda_check_board_codec_sid_config(codec,
10038                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10039
10040         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10041                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10042                        codec->chip_name);
10043                 board_config = ALC882_AUTO;
10044         }
10045
10046         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10047
10048         if (board_config == ALC882_AUTO) {
10049                 /* automatic parse from the BIOS config */
10050                 err = alc882_parse_auto_config(codec);
10051                 if (err < 0) {
10052                         alc_free(codec);
10053                         return err;
10054                 } else if (!err) {
10055                         printk(KERN_INFO
10056                                "hda_codec: Cannot set up configuration "
10057                                "from BIOS.  Using base mode...\n");
10058                         board_config = ALC882_3ST_DIG;
10059                 }
10060         }
10061
10062         err = snd_hda_attach_beep_device(codec, 0x1);
10063         if (err < 0) {
10064                 alc_free(codec);
10065                 return err;
10066         }
10067
10068         if (board_config != ALC882_AUTO)
10069                 setup_preset(codec, &alc882_presets[board_config]);
10070
10071         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10072         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10073         /* FIXME: setup DAC5 */
10074         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10075         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10076
10077         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10078         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10079
10080         if (codec->vendor_id == 0x10ec0888)
10081                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10082
10083         if (!spec->adc_nids && spec->input_mux) {
10084                 int i, j;
10085                 spec->num_adc_nids = 0;
10086                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10087                         const struct hda_input_mux *imux = spec->input_mux;
10088                         hda_nid_t cap;
10089                         hda_nid_t items[16];
10090                         hda_nid_t nid = alc882_adc_nids[i];
10091                         unsigned int wcap = get_wcaps(codec, nid);
10092                         /* get type */
10093                         wcap = get_wcaps_type(wcap);
10094                         if (wcap != AC_WID_AUD_IN)
10095                                 continue;
10096                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10097                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10098                         if (err < 0)
10099                                 continue;
10100                         err = snd_hda_get_connections(codec, cap, items,
10101                                                       ARRAY_SIZE(items));
10102                         if (err < 0)
10103                                 continue;
10104                         for (j = 0; j < imux->num_items; j++)
10105                                 if (imux->items[j].index >= err)
10106                                         break;
10107                         if (j < imux->num_items)
10108                                 continue;
10109                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10110                         spec->num_adc_nids++;
10111                 }
10112                 spec->adc_nids = spec->private_adc_nids;
10113                 spec->capsrc_nids = spec->private_capsrc_nids;
10114         }
10115
10116         set_capture_mixer(codec);
10117         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10118
10119         spec->vmaster_nid = 0x0c;
10120
10121         codec->patch_ops = alc_patch_ops;
10122         if (board_config == ALC882_AUTO)
10123                 spec->init_hook = alc882_auto_init;
10124 #ifdef CONFIG_SND_HDA_POWER_SAVE
10125         if (!spec->loopback.amplist)
10126                 spec->loopback.amplist = alc882_loopbacks;
10127 #endif
10128         codec->proc_widget_hook = print_realtek_coef;
10129
10130         return 0;
10131 }
10132
10133
10134 /*
10135  * ALC262 support
10136  */
10137
10138 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10139 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10140
10141 #define alc262_dac_nids         alc260_dac_nids
10142 #define alc262_adc_nids         alc882_adc_nids
10143 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10144 #define alc262_capsrc_nids      alc882_capsrc_nids
10145 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10146
10147 #define alc262_modes            alc260_modes
10148 #define alc262_capture_source   alc882_capture_source
10149
10150 static hda_nid_t alc262_dmic_adc_nids[1] = {
10151         /* ADC0 */
10152         0x09
10153 };
10154
10155 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10156
10157 static struct snd_kcontrol_new alc262_base_mixer[] = {
10158         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10159         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10160         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10161         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10162         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10163         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10164         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10165         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10166         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10167         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10168         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10169         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10170         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10171         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10172         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10173         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10174         { } /* end */
10175 };
10176
10177 /* update HP, line and mono-out pins according to the master switch */
10178 static void alc262_hp_master_update(struct hda_codec *codec)
10179 {
10180         struct alc_spec *spec = codec->spec;
10181         int val = spec->master_sw;
10182
10183         /* HP & line-out */
10184         snd_hda_codec_write_cache(codec, 0x1b, 0,
10185                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10186                                   val ? PIN_HP : 0);
10187         snd_hda_codec_write_cache(codec, 0x15, 0,
10188                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10189                                   val ? PIN_HP : 0);
10190         /* mono (speaker) depending on the HP jack sense */
10191         val = val && !spec->jack_present;
10192         snd_hda_codec_write_cache(codec, 0x16, 0,
10193                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10194                                   val ? PIN_OUT : 0);
10195 }
10196
10197 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10198 {
10199         struct alc_spec *spec = codec->spec;
10200
10201         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10202         alc262_hp_master_update(codec);
10203 }
10204
10205 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10206 {
10207         if ((res >> 26) != ALC880_HP_EVENT)
10208                 return;
10209         alc262_hp_bpc_automute(codec);
10210 }
10211
10212 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10213 {
10214         struct alc_spec *spec = codec->spec;
10215
10216         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10217         alc262_hp_master_update(codec);
10218 }
10219
10220 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10221                                            unsigned int res)
10222 {
10223         if ((res >> 26) != ALC880_HP_EVENT)
10224                 return;
10225         alc262_hp_wildwest_automute(codec);
10226 }
10227
10228 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10229
10230 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10231                                    struct snd_ctl_elem_value *ucontrol)
10232 {
10233         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10234         struct alc_spec *spec = codec->spec;
10235         int val = !!*ucontrol->value.integer.value;
10236
10237         if (val == spec->master_sw)
10238                 return 0;
10239         spec->master_sw = val;
10240         alc262_hp_master_update(codec);
10241         return 1;
10242 }
10243
10244 #define ALC262_HP_MASTER_SWITCH                                 \
10245         {                                                       \
10246                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10247                 .name = "Master Playback Switch",               \
10248                 .info = snd_ctl_boolean_mono_info,              \
10249                 .get = alc262_hp_master_sw_get,                 \
10250                 .put = alc262_hp_master_sw_put,                 \
10251         }
10252
10253 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10254         ALC262_HP_MASTER_SWITCH,
10255         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10256         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10257         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10258         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10259                               HDA_OUTPUT),
10260         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10261                             HDA_OUTPUT),
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         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10269         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10270         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10271         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10272         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10273         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10274         { } /* end */
10275 };
10276
10277 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10278         ALC262_HP_MASTER_SWITCH,
10279         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10280         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10281         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10282         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10283         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10284                               HDA_OUTPUT),
10285         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10286                             HDA_OUTPUT),
10287         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10288         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10289         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10290         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10291         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10292         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10293         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10294         { } /* end */
10295 };
10296
10297 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10298         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10299         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10300         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10301         { } /* end */
10302 };
10303
10304 /* mute/unmute internal speaker according to the hp jack and mute state */
10305 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10306 {
10307         struct alc_spec *spec = codec->spec;
10308
10309         spec->autocfg.hp_pins[0] = 0x15;
10310         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
10311 }
10312
10313 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10314         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10315         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10316         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10317         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10318         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10319         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10320         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10321         { } /* end */
10322 };
10323
10324 static struct hda_verb alc262_hp_t5735_verbs[] = {
10325         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10326         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10327
10328         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10329         { }
10330 };
10331
10332 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10333         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10334         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10335         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10336         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10337         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10338         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10339         { } /* end */
10340 };
10341
10342 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10343         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10344         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10345         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10346         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10347         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10348         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10349         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10350         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10351         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10352         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10353         {}
10354 };
10355
10356 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10357         .num_items = 1,
10358         .items = {
10359                 { "Line", 0x1 },
10360         },
10361 };
10362
10363 /* bind hp and internal speaker mute (with plug check) as master switch */
10364 static void alc262_hippo_master_update(struct hda_codec *codec)
10365 {
10366         struct alc_spec *spec = codec->spec;
10367         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10368         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10369         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10370         unsigned int mute;
10371
10372         /* HP */
10373         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10374         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10375                                  HDA_AMP_MUTE, mute);
10376         /* mute internal speaker per jack sense */
10377         if (spec->jack_present)
10378                 mute = HDA_AMP_MUTE;
10379         if (line_nid)
10380                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10381                                          HDA_AMP_MUTE, mute);
10382         if (speaker_nid && speaker_nid != line_nid)
10383                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10384                                          HDA_AMP_MUTE, mute);
10385 }
10386
10387 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10388
10389 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10390                                       struct snd_ctl_elem_value *ucontrol)
10391 {
10392         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10393         struct alc_spec *spec = codec->spec;
10394         int val = !!*ucontrol->value.integer.value;
10395
10396         if (val == spec->master_sw)
10397                 return 0;
10398         spec->master_sw = val;
10399         alc262_hippo_master_update(codec);
10400         return 1;
10401 }
10402
10403 #define ALC262_HIPPO_MASTER_SWITCH                              \
10404         {                                                       \
10405                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10406                 .name = "Master Playback Switch",               \
10407                 .info = snd_ctl_boolean_mono_info,              \
10408                 .get = alc262_hippo_master_sw_get,              \
10409                 .put = alc262_hippo_master_sw_put,              \
10410         }
10411
10412 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10413         ALC262_HIPPO_MASTER_SWITCH,
10414         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10415         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10416         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10417         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10418         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10419         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10420         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10421         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10422         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10423         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10424         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10425         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10426         { } /* end */
10427 };
10428
10429 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10430         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10431         ALC262_HIPPO_MASTER_SWITCH,
10432         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10433         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10434         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10435         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10436         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10437         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10438         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10439         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10440         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10441         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10442         { } /* end */
10443 };
10444
10445 /* mute/unmute internal speaker according to the hp jack and mute state */
10446 static void alc262_hippo_automute(struct hda_codec *codec)
10447 {
10448         struct alc_spec *spec = codec->spec;
10449         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10450
10451         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10452         alc262_hippo_master_update(codec);
10453 }
10454
10455 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10456 {
10457         if ((res >> 26) != ALC880_HP_EVENT)
10458                 return;
10459         alc262_hippo_automute(codec);
10460 }
10461
10462 static void alc262_hippo_setup(struct hda_codec *codec)
10463 {
10464         struct alc_spec *spec = codec->spec;
10465
10466         spec->autocfg.hp_pins[0] = 0x15;
10467         spec->autocfg.speaker_pins[0] = 0x14;
10468 }
10469
10470 static void alc262_hippo1_setup(struct hda_codec *codec)
10471 {
10472         struct alc_spec *spec = codec->spec;
10473
10474         spec->autocfg.hp_pins[0] = 0x1b;
10475         spec->autocfg.speaker_pins[0] = 0x14;
10476 }
10477
10478
10479 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10480         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10481         ALC262_HIPPO_MASTER_SWITCH,
10482         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10483         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10484         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10485         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10486         { } /* end */
10487 };
10488
10489 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10490         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10491         ALC262_HIPPO_MASTER_SWITCH,
10492         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10493         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10494         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10495         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10496         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10497         { } /* end */
10498 };
10499
10500 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10501         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10502         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10503         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10504         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10505         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10506         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10507         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10508         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10509         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10510         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10511         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10512         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10513         { } /* end */
10514 };
10515
10516 static struct hda_verb alc262_tyan_verbs[] = {
10517         /* Headphone automute */
10518         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10519         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10520         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10521
10522         /* P11 AUX_IN, white 4-pin connector */
10523         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10524         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10525         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10526         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10527
10528         {}
10529 };
10530
10531 /* unsolicited event for HP jack sensing */
10532 static void alc262_tyan_setup(struct hda_codec *codec)
10533 {
10534         struct alc_spec *spec = codec->spec;
10535
10536         spec->autocfg.hp_pins[0] = 0x1b;
10537         spec->autocfg.speaker_pins[0] = 0x15;
10538 }
10539
10540
10541 #define alc262_capture_mixer            alc882_capture_mixer
10542 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10543
10544 /*
10545  * generic initialization of ADC, input mixers and output mixers
10546  */
10547 static struct hda_verb alc262_init_verbs[] = {
10548         /*
10549          * Unmute ADC0-2 and set the default input to mic-in
10550          */
10551         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10553         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10554         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10555         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10556         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10557
10558         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10559          * mixer widget
10560          * Note: PASD motherboards uses the Line In 2 as the input for
10561          * front panel mic (mic 2)
10562          */
10563         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10564         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10565         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10566         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10567         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10568         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10569
10570         /*
10571          * Set up output mixers (0x0c - 0x0e)
10572          */
10573         /* set vol=0 to output mixers */
10574         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10575         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10576         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10577         /* set up input amps for analog loopback */
10578         /* Amp Indices: DAC = 0, mixer = 1 */
10579         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10580         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10581         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10582         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10583         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10584         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10585
10586         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10587         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10588         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10589         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10590         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10591         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10592
10593         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10594         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10595         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10596         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10597         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10598
10599         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10600         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10601
10602         /* FIXME: use matrix-type input source selection */
10603         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10604         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10605         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10606         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10607         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10608         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10609         /* Input mixer2 */
10610         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10611         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10612         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10613         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10614         /* Input mixer3 */
10615         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10616         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10619
10620         { }
10621 };
10622
10623 static struct hda_verb alc262_eapd_verbs[] = {
10624         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10625         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10626         { }
10627 };
10628
10629 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10630         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10631         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10632         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10633
10634         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10635         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10636         {}
10637 };
10638
10639 static struct hda_verb alc262_sony_unsol_verbs[] = {
10640         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10641         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10642         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10643
10644         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10645         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10646         {}
10647 };
10648
10649 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10650         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10651         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10652         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10653         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10654         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10655         { } /* end */
10656 };
10657
10658 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10659         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10660         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10661         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10662         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10663         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10664         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10665         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10666         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10667         {}
10668 };
10669
10670 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10671 {
10672         struct alc_spec *spec = codec->spec;
10673
10674         spec->autocfg.hp_pins[0] = 0x15;
10675         spec->autocfg.speaker_pins[0] = 0x14;
10676         spec->ext_mic.pin = 0x18;
10677         spec->ext_mic.mux_idx = 0;
10678         spec->int_mic.pin = 0x12;
10679         spec->int_mic.mux_idx = 9;
10680         spec->auto_mic = 1;
10681 }
10682
10683 /*
10684  * nec model
10685  *  0x15 = headphone
10686  *  0x16 = internal speaker
10687  *  0x18 = external mic
10688  */
10689
10690 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10691         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10692         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10693
10694         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10695         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10696         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10697
10698         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10699         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10700         { } /* end */
10701 };
10702
10703 static struct hda_verb alc262_nec_verbs[] = {
10704         /* Unmute Speaker */
10705         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10706
10707         /* Headphone */
10708         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10709         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10710
10711         /* External mic to headphone */
10712         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10713         /* External mic to speaker */
10714         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10715         {}
10716 };
10717
10718 /*
10719  * fujitsu model
10720  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10721  *  0x1b = port replicator headphone out
10722  */
10723
10724 #define ALC_HP_EVENT    0x37
10725
10726 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10727         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10728         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10729         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10730         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10731         {}
10732 };
10733
10734 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10735         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10736         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10737         {}
10738 };
10739
10740 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
10741         /* Front Mic pin: input vref at 50% */
10742         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
10743         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10744         {}
10745 };
10746
10747 static struct hda_input_mux alc262_fujitsu_capture_source = {
10748         .num_items = 3,
10749         .items = {
10750                 { "Mic", 0x0 },
10751                 { "Int Mic", 0x1 },
10752                 { "CD", 0x4 },
10753         },
10754 };
10755
10756 static struct hda_input_mux alc262_HP_capture_source = {
10757         .num_items = 5,
10758         .items = {
10759                 { "Mic", 0x0 },
10760                 { "Front Mic", 0x1 },
10761                 { "Line", 0x2 },
10762                 { "CD", 0x4 },
10763                 { "AUX IN", 0x6 },
10764         },
10765 };
10766
10767 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10768         .num_items = 4,
10769         .items = {
10770                 { "Mic", 0x0 },
10771                 { "Front Mic", 0x2 },
10772                 { "Line", 0x1 },
10773                 { "CD", 0x4 },
10774         },
10775 };
10776
10777 /* mute/unmute internal speaker according to the hp jacks and mute state */
10778 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10779 {
10780         struct alc_spec *spec = codec->spec;
10781         unsigned int mute;
10782
10783         if (force || !spec->sense_updated) {
10784                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
10785                                      snd_hda_jack_detect(codec, 0x1b);
10786                 spec->sense_updated = 1;
10787         }
10788         /* unmute internal speaker only if both HPs are unplugged and
10789          * master switch is on
10790          */
10791         if (spec->jack_present)
10792                 mute = HDA_AMP_MUTE;
10793         else
10794                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10795         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10796                                  HDA_AMP_MUTE, mute);
10797 }
10798
10799 /* unsolicited event for HP jack sensing */
10800 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10801                                        unsigned int res)
10802 {
10803         if ((res >> 26) != ALC_HP_EVENT)
10804                 return;
10805         alc262_fujitsu_automute(codec, 1);
10806 }
10807
10808 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10809 {
10810         alc262_fujitsu_automute(codec, 1);
10811 }
10812
10813 /* bind volumes of both NID 0x0c and 0x0d */
10814 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10815         .ops = &snd_hda_bind_vol,
10816         .values = {
10817                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10818                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10819                 0
10820         },
10821 };
10822
10823 /* mute/unmute internal speaker according to the hp jack and mute state */
10824 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10825 {
10826         struct alc_spec *spec = codec->spec;
10827         unsigned int mute;
10828
10829         if (force || !spec->sense_updated) {
10830                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10831                 spec->sense_updated = 1;
10832         }
10833         if (spec->jack_present) {
10834                 /* mute internal speaker */
10835                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10836                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10837                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10838                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10839         } else {
10840                 /* unmute internal speaker if necessary */
10841                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10842                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10843                                          HDA_AMP_MUTE, mute);
10844                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10845                                          HDA_AMP_MUTE, mute);
10846         }
10847 }
10848
10849 /* unsolicited event for HP jack sensing */
10850 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10851                                        unsigned int res)
10852 {
10853         if ((res >> 26) != ALC_HP_EVENT)
10854                 return;
10855         alc262_lenovo_3000_automute(codec, 1);
10856 }
10857
10858 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10859                                   int dir, int idx, long *valp)
10860 {
10861         int i, change = 0;
10862
10863         for (i = 0; i < 2; i++, valp++)
10864                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10865                                                    HDA_AMP_MUTE,
10866                                                    *valp ? 0 : HDA_AMP_MUTE);
10867         return change;
10868 }
10869
10870 /* bind hp and internal speaker mute (with plug check) */
10871 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10872                                          struct snd_ctl_elem_value *ucontrol)
10873 {
10874         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10875         long *valp = ucontrol->value.integer.value;
10876         int change;
10877
10878         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10879         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10880         if (change)
10881                 alc262_fujitsu_automute(codec, 0);
10882         return change;
10883 }
10884
10885 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10886         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10887         {
10888                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10889                 .name = "Master Playback Switch",
10890                 .info = snd_hda_mixer_amp_switch_info,
10891                 .get = snd_hda_mixer_amp_switch_get,
10892                 .put = alc262_fujitsu_master_sw_put,
10893                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10894         },
10895         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10896         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10897         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10899         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10900         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10901         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10902         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10903         { } /* end */
10904 };
10905
10906 /* bind hp and internal speaker mute (with plug check) */
10907 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10908                                          struct snd_ctl_elem_value *ucontrol)
10909 {
10910         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10911         long *valp = ucontrol->value.integer.value;
10912         int change;
10913
10914         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10915         if (change)
10916                 alc262_lenovo_3000_automute(codec, 0);
10917         return change;
10918 }
10919
10920 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10921         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10922         {
10923                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10924                 .name = "Master Playback Switch",
10925                 .info = snd_hda_mixer_amp_switch_info,
10926                 .get = snd_hda_mixer_amp_switch_get,
10927                 .put = alc262_lenovo_3000_master_sw_put,
10928                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10929         },
10930         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10931         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10932         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10933         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10934         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10935         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10936         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10937         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10938         { } /* end */
10939 };
10940
10941 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10942         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10943         ALC262_HIPPO_MASTER_SWITCH,
10944         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10945         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10946         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10947         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10948         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10949         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10950         { } /* end */
10951 };
10952
10953 /* additional init verbs for Benq laptops */
10954 static struct hda_verb alc262_EAPD_verbs[] = {
10955         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10956         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10957         {}
10958 };
10959
10960 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10961         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10962         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10963
10964         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10965         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10966         {}
10967 };
10968
10969 /* Samsung Q1 Ultra Vista model setup */
10970 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10971         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10972         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10973         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10974         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10975         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10976         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10977         { } /* end */
10978 };
10979
10980 static struct hda_verb alc262_ultra_verbs[] = {
10981         /* output mixer */
10982         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10983         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10984         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10985         /* speaker */
10986         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10987         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10988         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10989         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10990         /* HP */
10991         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10992         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10993         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10994         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10995         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10996         /* internal mic */
10997         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10998         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10999         /* ADC, choose mic */
11000         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11001         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11002         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11003         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11004         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11005         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11006         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11007         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11008         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11009         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11010         {}
11011 };
11012
11013 /* mute/unmute internal speaker according to the hp jack and mute state */
11014 static void alc262_ultra_automute(struct hda_codec *codec)
11015 {
11016         struct alc_spec *spec = codec->spec;
11017         unsigned int mute;
11018
11019         mute = 0;
11020         /* auto-mute only when HP is used as HP */
11021         if (!spec->cur_mux[0]) {
11022                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11023                 if (spec->jack_present)
11024                         mute = HDA_AMP_MUTE;
11025         }
11026         /* mute/unmute internal speaker */
11027         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11028                                  HDA_AMP_MUTE, mute);
11029         /* mute/unmute HP */
11030         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11031                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11032 }
11033
11034 /* unsolicited event for HP jack sensing */
11035 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11036                                        unsigned int res)
11037 {
11038         if ((res >> 26) != ALC880_HP_EVENT)
11039                 return;
11040         alc262_ultra_automute(codec);
11041 }
11042
11043 static struct hda_input_mux alc262_ultra_capture_source = {
11044         .num_items = 2,
11045         .items = {
11046                 { "Mic", 0x1 },
11047                 { "Headphone", 0x7 },
11048         },
11049 };
11050
11051 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11052                                      struct snd_ctl_elem_value *ucontrol)
11053 {
11054         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11055         struct alc_spec *spec = codec->spec;
11056         int ret;
11057
11058         ret = alc_mux_enum_put(kcontrol, ucontrol);
11059         if (!ret)
11060                 return 0;
11061         /* reprogram the HP pin as mic or HP according to the input source */
11062         snd_hda_codec_write_cache(codec, 0x15, 0,
11063                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11064                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11065         alc262_ultra_automute(codec); /* mute/unmute HP */
11066         return ret;
11067 }
11068
11069 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11070         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11071         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11072         {
11073                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11074                 .name = "Capture Source",
11075                 .info = alc_mux_enum_info,
11076                 .get = alc_mux_enum_get,
11077                 .put = alc262_ultra_mux_enum_put,
11078         },
11079         { } /* end */
11080 };
11081
11082 /* We use two mixers depending on the output pin; 0x16 is a mono output
11083  * and thus it's bound with a different mixer.
11084  * This function returns which mixer amp should be used.
11085  */
11086 static int alc262_check_volbit(hda_nid_t nid)
11087 {
11088         if (!nid)
11089                 return 0;
11090         else if (nid == 0x16)
11091                 return 2;
11092         else
11093                 return 1;
11094 }
11095
11096 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11097                                   const char *pfx, int *vbits)
11098 {
11099         unsigned long val;
11100         int vbit;
11101
11102         vbit = alc262_check_volbit(nid);
11103         if (!vbit)
11104                 return 0;
11105         if (*vbits & vbit) /* a volume control for this mixer already there */
11106                 return 0;
11107         *vbits |= vbit;
11108         if (vbit == 2)
11109                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11110         else
11111                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11112         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11113 }
11114
11115 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11116                                  const char *pfx)
11117 {
11118         unsigned long val;
11119
11120         if (!nid)
11121                 return 0;
11122         if (nid == 0x16)
11123                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11124         else
11125                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11126         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11127 }
11128
11129 /* add playback controls from the parsed DAC table */
11130 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11131                                              const struct auto_pin_cfg *cfg)
11132 {
11133         const char *pfx;
11134         int vbits;
11135         int err;
11136
11137         spec->multiout.num_dacs = 1;    /* only use one dac */
11138         spec->multiout.dac_nids = spec->private_dac_nids;
11139         spec->multiout.dac_nids[0] = 2;
11140
11141         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11142                 pfx = "Master";
11143         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11144                 pfx = "Speaker";
11145         else
11146                 pfx = "Front";
11147         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11148         if (err < 0)
11149                 return err;
11150         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11151         if (err < 0)
11152                 return err;
11153         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11154         if (err < 0)
11155                 return err;
11156
11157         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11158                 alc262_check_volbit(cfg->speaker_pins[0]) |
11159                 alc262_check_volbit(cfg->hp_pins[0]);
11160         if (vbits == 1 || vbits == 2)
11161                 pfx = "Master"; /* only one mixer is used */
11162         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11163                 pfx = "Speaker";
11164         else
11165                 pfx = "Front";
11166         vbits = 0;
11167         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11168         if (err < 0)
11169                 return err;
11170         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11171                                      &vbits);
11172         if (err < 0)
11173                 return err;
11174         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11175                                      &vbits);
11176         if (err < 0)
11177                 return err;
11178         return 0;
11179 }
11180
11181 #define alc262_auto_create_input_ctls \
11182         alc880_auto_create_input_ctls
11183
11184 /*
11185  * generic initialization of ADC, input mixers and output mixers
11186  */
11187 static struct hda_verb alc262_volume_init_verbs[] = {
11188         /*
11189          * Unmute ADC0-2 and set the default input to mic-in
11190          */
11191         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11192         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11193         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11194         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11195         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11196         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11197
11198         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11199          * mixer widget
11200          * Note: PASD motherboards uses the Line In 2 as the input for
11201          * front panel mic (mic 2)
11202          */
11203         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11204         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11205         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11206         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11207         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11208         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11209
11210         /*
11211          * Set up output mixers (0x0c - 0x0f)
11212          */
11213         /* set vol=0 to output mixers */
11214         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11215         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11216         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11217
11218         /* set up input amps for analog loopback */
11219         /* Amp Indices: DAC = 0, mixer = 1 */
11220         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11221         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11222         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11223         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11224         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11225         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11226
11227         /* FIXME: use matrix-type input source selection */
11228         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11229         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11230         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11231         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11232         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11233         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11234         /* Input mixer2 */
11235         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11236         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11237         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11238         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11239         /* Input mixer3 */
11240         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11241         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11242         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11243         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11244
11245         { }
11246 };
11247
11248 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11249         /*
11250          * Unmute ADC0-2 and set the default input to mic-in
11251          */
11252         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11254         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11255         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11256         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11257         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11258
11259         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11260          * mixer widget
11261          * Note: PASD motherboards uses the Line In 2 as the input for
11262          * front panel mic (mic 2)
11263          */
11264         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11265         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11266         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11267         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11268         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11269         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11270         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11271         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11272
11273         /*
11274          * Set up output mixers (0x0c - 0x0e)
11275          */
11276         /* set vol=0 to output mixers */
11277         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11278         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11279         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11280
11281         /* set up input amps for analog loopback */
11282         /* Amp Indices: DAC = 0, mixer = 1 */
11283         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11284         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11285         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11286         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11287         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11288         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11289
11290         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11291         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11292         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11293
11294         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11295         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11296
11297         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11298         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11299
11300         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11301         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11302         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11303         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11304         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11305
11306         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11307         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11308         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11309         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11310         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11311         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11312
11313
11314         /* FIXME: use matrix-type input source selection */
11315         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11316         /* Input mixer1: only unmute Mic */
11317         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11318         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11319         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11320         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11321         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11326         /* Input mixer2 */
11327         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11328         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11330         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11331         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11332         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11333         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11334         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11335         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11336         /* Input mixer3 */
11337         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11338         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11339         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11340         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11341         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11342         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11343         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11344         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11346
11347         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11348
11349         { }
11350 };
11351
11352 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11353         /*
11354          * Unmute ADC0-2 and set the default input to mic-in
11355          */
11356         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11357         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11358         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11359         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11360         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11361         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11362
11363         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11364          * mixer widget
11365          * Note: PASD motherboards uses the Line In 2 as the input for front
11366          * panel mic (mic 2)
11367          */
11368         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11369         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11370         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11371         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11372         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11373         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11374         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11375         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11376         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11377         /*
11378          * Set up output mixers (0x0c - 0x0e)
11379          */
11380         /* set vol=0 to output mixers */
11381         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11382         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11383         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11384
11385         /* set up input amps for analog loopback */
11386         /* Amp Indices: DAC = 0, mixer = 1 */
11387         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11388         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11389         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11390         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11391         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11392         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11393
11394
11395         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11396         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11397         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11398         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11399         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11400         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11401         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11402
11403         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11404         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11405
11406         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11407         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11408
11409         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11410         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11411         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11412         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11413         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11414         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11415
11416         /* FIXME: use matrix-type input source selection */
11417         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11418         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11419         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11420         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11421         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11422         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11423         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11424         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11425         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11426         /* Input mixer2 */
11427         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11428         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11429         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11430         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11431         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11432         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11433         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11434         /* Input mixer3 */
11435         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11436         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11437         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11438         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11439         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11440         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11441         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11442
11443         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11444
11445         { }
11446 };
11447
11448 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11449
11450         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11451         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11452         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11453
11454         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11455         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11456         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11457         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11458
11459         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11460         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11461         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11462         {}
11463 };
11464
11465
11466 #ifdef CONFIG_SND_HDA_POWER_SAVE
11467 #define alc262_loopbacks        alc880_loopbacks
11468 #endif
11469
11470 /* pcm configuration: identical with ALC880 */
11471 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11472 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11473 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11474 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11475
11476 /*
11477  * BIOS auto configuration
11478  */
11479 static int alc262_parse_auto_config(struct hda_codec *codec)
11480 {
11481         struct alc_spec *spec = codec->spec;
11482         int err;
11483         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11484
11485         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11486                                            alc262_ignore);
11487         if (err < 0)
11488                 return err;
11489         if (!spec->autocfg.line_outs) {
11490                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11491                         spec->multiout.max_channels = 2;
11492                         spec->no_analog = 1;
11493                         goto dig_only;
11494                 }
11495                 return 0; /* can't find valid BIOS pin config */
11496         }
11497         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11498         if (err < 0)
11499                 return err;
11500         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11501         if (err < 0)
11502                 return err;
11503
11504         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11505
11506  dig_only:
11507         if (spec->autocfg.dig_outs) {
11508                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11509                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11510         }
11511         if (spec->autocfg.dig_in_pin)
11512                 spec->dig_in_nid = ALC262_DIGIN_NID;
11513
11514         if (spec->kctls.list)
11515                 add_mixer(spec, spec->kctls.list);
11516
11517         add_verb(spec, alc262_volume_init_verbs);
11518         spec->num_mux_defs = 1;
11519         spec->input_mux = &spec->private_imux[0];
11520
11521         err = alc_auto_add_mic_boost(codec);
11522         if (err < 0)
11523                 return err;
11524
11525         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11526
11527         return 1;
11528 }
11529
11530 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11531 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11532 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11533 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11534
11535
11536 /* init callback for auto-configuration model -- overriding the default init */
11537 static void alc262_auto_init(struct hda_codec *codec)
11538 {
11539         struct alc_spec *spec = codec->spec;
11540         alc262_auto_init_multi_out(codec);
11541         alc262_auto_init_hp_out(codec);
11542         alc262_auto_init_analog_input(codec);
11543         alc262_auto_init_input_src(codec);
11544         if (spec->unsol_event)
11545                 alc_inithook(codec);
11546 }
11547
11548 /*
11549  * configuration and preset
11550  */
11551 static const char *alc262_models[ALC262_MODEL_LAST] = {
11552         [ALC262_BASIC]          = "basic",
11553         [ALC262_HIPPO]          = "hippo",
11554         [ALC262_HIPPO_1]        = "hippo_1",
11555         [ALC262_FUJITSU]        = "fujitsu",
11556         [ALC262_HP_BPC]         = "hp-bpc",
11557         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11558         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11559         [ALC262_HP_RP5700]      = "hp-rp5700",
11560         [ALC262_BENQ_ED8]       = "benq",
11561         [ALC262_BENQ_T31]       = "benq-t31",
11562         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11563         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11564         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11565         [ALC262_ULTRA]          = "ultra",
11566         [ALC262_LENOVO_3000]    = "lenovo-3000",
11567         [ALC262_NEC]            = "nec",
11568         [ALC262_TYAN]           = "tyan",
11569         [ALC262_AUTO]           = "auto",
11570 };
11571
11572 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11573         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11574         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11575         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11576                            ALC262_HP_BPC),
11577         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11578                            ALC262_HP_BPC),
11579         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11580                            ALC262_HP_BPC),
11581         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11582         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11583         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11584         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11585         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11586         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11587         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11588         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11589         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11590         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11591         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11592         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11593                       ALC262_HP_TC_T5735),
11594         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11595         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11596         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11597         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11598         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11599         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11600         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11601         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11602 #if 0 /* disable the quirk since model=auto works better in recent versions */
11603         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11604                            ALC262_SONY_ASSAMD),
11605 #endif
11606         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11607                       ALC262_TOSHIBA_RX1),
11608         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11609         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11610         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11611         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11612         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11613                            ALC262_ULTRA),
11614         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11615         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11616         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11617         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11618         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11619         {}
11620 };
11621
11622 static struct alc_config_preset alc262_presets[] = {
11623         [ALC262_BASIC] = {
11624                 .mixers = { alc262_base_mixer },
11625                 .init_verbs = { alc262_init_verbs },
11626                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11627                 .dac_nids = alc262_dac_nids,
11628                 .hp_nid = 0x03,
11629                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11630                 .channel_mode = alc262_modes,
11631                 .input_mux = &alc262_capture_source,
11632         },
11633         [ALC262_HIPPO] = {
11634                 .mixers = { alc262_hippo_mixer },
11635                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11636                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11637                 .dac_nids = alc262_dac_nids,
11638                 .hp_nid = 0x03,
11639                 .dig_out_nid = ALC262_DIGOUT_NID,
11640                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11641                 .channel_mode = alc262_modes,
11642                 .input_mux = &alc262_capture_source,
11643                 .unsol_event = alc262_hippo_unsol_event,
11644                 .setup = alc262_hippo_setup,
11645                 .init_hook = alc262_hippo_automute,
11646         },
11647         [ALC262_HIPPO_1] = {
11648                 .mixers = { alc262_hippo1_mixer },
11649                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11650                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11651                 .dac_nids = alc262_dac_nids,
11652                 .hp_nid = 0x02,
11653                 .dig_out_nid = ALC262_DIGOUT_NID,
11654                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11655                 .channel_mode = alc262_modes,
11656                 .input_mux = &alc262_capture_source,
11657                 .unsol_event = alc262_hippo_unsol_event,
11658                 .setup = alc262_hippo1_setup,
11659                 .init_hook = alc262_hippo_automute,
11660         },
11661         [ALC262_FUJITSU] = {
11662                 .mixers = { alc262_fujitsu_mixer },
11663                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11664                                 alc262_fujitsu_unsol_verbs },
11665                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11666                 .dac_nids = alc262_dac_nids,
11667                 .hp_nid = 0x03,
11668                 .dig_out_nid = ALC262_DIGOUT_NID,
11669                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11670                 .channel_mode = alc262_modes,
11671                 .input_mux = &alc262_fujitsu_capture_source,
11672                 .unsol_event = alc262_fujitsu_unsol_event,
11673                 .init_hook = alc262_fujitsu_init_hook,
11674         },
11675         [ALC262_HP_BPC] = {
11676                 .mixers = { alc262_HP_BPC_mixer },
11677                 .init_verbs = { alc262_HP_BPC_init_verbs },
11678                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11679                 .dac_nids = alc262_dac_nids,
11680                 .hp_nid = 0x03,
11681                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11682                 .channel_mode = alc262_modes,
11683                 .input_mux = &alc262_HP_capture_source,
11684                 .unsol_event = alc262_hp_bpc_unsol_event,
11685                 .init_hook = alc262_hp_bpc_automute,
11686         },
11687         [ALC262_HP_BPC_D7000_WF] = {
11688                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11689                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11690                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11691                 .dac_nids = alc262_dac_nids,
11692                 .hp_nid = 0x03,
11693                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11694                 .channel_mode = alc262_modes,
11695                 .input_mux = &alc262_HP_D7000_capture_source,
11696                 .unsol_event = alc262_hp_wildwest_unsol_event,
11697                 .init_hook = alc262_hp_wildwest_automute,
11698         },
11699         [ALC262_HP_BPC_D7000_WL] = {
11700                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11701                             alc262_HP_BPC_WildWest_option_mixer },
11702                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11703                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11704                 .dac_nids = alc262_dac_nids,
11705                 .hp_nid = 0x03,
11706                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11707                 .channel_mode = alc262_modes,
11708                 .input_mux = &alc262_HP_D7000_capture_source,
11709                 .unsol_event = alc262_hp_wildwest_unsol_event,
11710                 .init_hook = alc262_hp_wildwest_automute,
11711         },
11712         [ALC262_HP_TC_T5735] = {
11713                 .mixers = { alc262_hp_t5735_mixer },
11714                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11715                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11716                 .dac_nids = alc262_dac_nids,
11717                 .hp_nid = 0x03,
11718                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11719                 .channel_mode = alc262_modes,
11720                 .input_mux = &alc262_capture_source,
11721                 .unsol_event = alc_automute_amp_unsol_event,
11722                 .setup = alc262_hp_t5735_setup,
11723                 .init_hook = alc_automute_amp,
11724         },
11725         [ALC262_HP_RP5700] = {
11726                 .mixers = { alc262_hp_rp5700_mixer },
11727                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11728                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11729                 .dac_nids = alc262_dac_nids,
11730                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11731                 .channel_mode = alc262_modes,
11732                 .input_mux = &alc262_hp_rp5700_capture_source,
11733         },
11734         [ALC262_BENQ_ED8] = {
11735                 .mixers = { alc262_base_mixer },
11736                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11737                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11738                 .dac_nids = alc262_dac_nids,
11739                 .hp_nid = 0x03,
11740                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11741                 .channel_mode = alc262_modes,
11742                 .input_mux = &alc262_capture_source,
11743         },
11744         [ALC262_SONY_ASSAMD] = {
11745                 .mixers = { alc262_sony_mixer },
11746                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11747                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11748                 .dac_nids = alc262_dac_nids,
11749                 .hp_nid = 0x02,
11750                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11751                 .channel_mode = alc262_modes,
11752                 .input_mux = &alc262_capture_source,
11753                 .unsol_event = alc262_hippo_unsol_event,
11754                 .setup = alc262_hippo_setup,
11755                 .init_hook = alc262_hippo_automute,
11756         },
11757         [ALC262_BENQ_T31] = {
11758                 .mixers = { alc262_benq_t31_mixer },
11759                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11760                                 alc_hp15_unsol_verbs },
11761                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11762                 .dac_nids = alc262_dac_nids,
11763                 .hp_nid = 0x03,
11764                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11765                 .channel_mode = alc262_modes,
11766                 .input_mux = &alc262_capture_source,
11767                 .unsol_event = alc262_hippo_unsol_event,
11768                 .setup = alc262_hippo_setup,
11769                 .init_hook = alc262_hippo_automute,
11770         },
11771         [ALC262_ULTRA] = {
11772                 .mixers = { alc262_ultra_mixer },
11773                 .cap_mixer = alc262_ultra_capture_mixer,
11774                 .init_verbs = { alc262_ultra_verbs },
11775                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11776                 .dac_nids = alc262_dac_nids,
11777                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11778                 .channel_mode = alc262_modes,
11779                 .input_mux = &alc262_ultra_capture_source,
11780                 .adc_nids = alc262_adc_nids, /* ADC0 */
11781                 .capsrc_nids = alc262_capsrc_nids,
11782                 .num_adc_nids = 1, /* single ADC */
11783                 .unsol_event = alc262_ultra_unsol_event,
11784                 .init_hook = alc262_ultra_automute,
11785         },
11786         [ALC262_LENOVO_3000] = {
11787                 .mixers = { alc262_lenovo_3000_mixer },
11788                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11789                                 alc262_lenovo_3000_unsol_verbs,
11790                                 alc262_lenovo_3000_init_verbs },
11791                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11792                 .dac_nids = alc262_dac_nids,
11793                 .hp_nid = 0x03,
11794                 .dig_out_nid = ALC262_DIGOUT_NID,
11795                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11796                 .channel_mode = alc262_modes,
11797                 .input_mux = &alc262_fujitsu_capture_source,
11798                 .unsol_event = alc262_lenovo_3000_unsol_event,
11799         },
11800         [ALC262_NEC] = {
11801                 .mixers = { alc262_nec_mixer },
11802                 .init_verbs = { alc262_nec_verbs },
11803                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11804                 .dac_nids = alc262_dac_nids,
11805                 .hp_nid = 0x03,
11806                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11807                 .channel_mode = alc262_modes,
11808                 .input_mux = &alc262_capture_source,
11809         },
11810         [ALC262_TOSHIBA_S06] = {
11811                 .mixers = { alc262_toshiba_s06_mixer },
11812                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11813                                                         alc262_eapd_verbs },
11814                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11815                 .capsrc_nids = alc262_dmic_capsrc_nids,
11816                 .dac_nids = alc262_dac_nids,
11817                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11818                 .num_adc_nids = 1, /* single ADC */
11819                 .dig_out_nid = ALC262_DIGOUT_NID,
11820                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11821                 .channel_mode = alc262_modes,
11822                 .unsol_event = alc_sku_unsol_event,
11823                 .setup = alc262_toshiba_s06_setup,
11824                 .init_hook = alc_inithook,
11825         },
11826         [ALC262_TOSHIBA_RX1] = {
11827                 .mixers = { alc262_toshiba_rx1_mixer },
11828                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11829                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11830                 .dac_nids = alc262_dac_nids,
11831                 .hp_nid = 0x03,
11832                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11833                 .channel_mode = alc262_modes,
11834                 .input_mux = &alc262_capture_source,
11835                 .unsol_event = alc262_hippo_unsol_event,
11836                 .setup = alc262_hippo_setup,
11837                 .init_hook = alc262_hippo_automute,
11838         },
11839         [ALC262_TYAN] = {
11840                 .mixers = { alc262_tyan_mixer },
11841                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11842                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11843                 .dac_nids = alc262_dac_nids,
11844                 .hp_nid = 0x02,
11845                 .dig_out_nid = ALC262_DIGOUT_NID,
11846                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11847                 .channel_mode = alc262_modes,
11848                 .input_mux = &alc262_capture_source,
11849                 .unsol_event = alc_automute_amp_unsol_event,
11850                 .setup = alc262_tyan_setup,
11851                 .init_hook = alc_automute_amp,
11852         },
11853 };
11854
11855 static int patch_alc262(struct hda_codec *codec)
11856 {
11857         struct alc_spec *spec;
11858         int board_config;
11859         int err;
11860
11861         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11862         if (spec == NULL)
11863                 return -ENOMEM;
11864
11865         codec->spec = spec;
11866 #if 0
11867         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11868          * under-run
11869          */
11870         {
11871         int tmp;
11872         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11873         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11874         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11875         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11876         }
11877 #endif
11878
11879         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11880
11881         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11882                                                   alc262_models,
11883                                                   alc262_cfg_tbl);
11884
11885         if (board_config < 0) {
11886                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11887                        codec->chip_name);
11888                 board_config = ALC262_AUTO;
11889         }
11890
11891         if (board_config == ALC262_AUTO) {
11892                 /* automatic parse from the BIOS config */
11893                 err = alc262_parse_auto_config(codec);
11894                 if (err < 0) {
11895                         alc_free(codec);
11896                         return err;
11897                 } else if (!err) {
11898                         printk(KERN_INFO
11899                                "hda_codec: Cannot set up configuration "
11900                                "from BIOS.  Using base mode...\n");
11901                         board_config = ALC262_BASIC;
11902                 }
11903         }
11904
11905         if (!spec->no_analog) {
11906                 err = snd_hda_attach_beep_device(codec, 0x1);
11907                 if (err < 0) {
11908                         alc_free(codec);
11909                         return err;
11910                 }
11911         }
11912
11913         if (board_config != ALC262_AUTO)
11914                 setup_preset(codec, &alc262_presets[board_config]);
11915
11916         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11917         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11918
11919         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11920         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11921
11922         if (!spec->adc_nids && spec->input_mux) {
11923                 int i;
11924                 /* check whether the digital-mic has to be supported */
11925                 for (i = 0; i < spec->input_mux->num_items; i++) {
11926                         if (spec->input_mux->items[i].index >= 9)
11927                                 break;
11928                 }
11929                 if (i < spec->input_mux->num_items) {
11930                         /* use only ADC0 */
11931                         spec->adc_nids = alc262_dmic_adc_nids;
11932                         spec->num_adc_nids = 1;
11933                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11934                 } else {
11935                         /* all analog inputs */
11936                         /* check whether NID 0x07 is valid */
11937                         unsigned int wcap = get_wcaps(codec, 0x07);
11938
11939                         /* get type */
11940                         wcap = get_wcaps_type(wcap);
11941                         if (wcap != AC_WID_AUD_IN) {
11942                                 spec->adc_nids = alc262_adc_nids_alt;
11943                                 spec->num_adc_nids =
11944                                         ARRAY_SIZE(alc262_adc_nids_alt);
11945                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11946                         } else {
11947                                 spec->adc_nids = alc262_adc_nids;
11948                                 spec->num_adc_nids =
11949                                         ARRAY_SIZE(alc262_adc_nids);
11950                                 spec->capsrc_nids = alc262_capsrc_nids;
11951                         }
11952                 }
11953         }
11954         if (!spec->cap_mixer && !spec->no_analog)
11955                 set_capture_mixer(codec);
11956         if (!spec->no_analog)
11957                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11958
11959         spec->vmaster_nid = 0x0c;
11960
11961         codec->patch_ops = alc_patch_ops;
11962         if (board_config == ALC262_AUTO)
11963                 spec->init_hook = alc262_auto_init;
11964 #ifdef CONFIG_SND_HDA_POWER_SAVE
11965         if (!spec->loopback.amplist)
11966                 spec->loopback.amplist = alc262_loopbacks;
11967 #endif
11968         codec->proc_widget_hook = print_realtek_coef;
11969
11970         return 0;
11971 }
11972
11973 /*
11974  *  ALC268 channel source setting (2 channel)
11975  */
11976 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11977 #define alc268_modes            alc260_modes
11978
11979 static hda_nid_t alc268_dac_nids[2] = {
11980         /* front, hp */
11981         0x02, 0x03
11982 };
11983
11984 static hda_nid_t alc268_adc_nids[2] = {
11985         /* ADC0-1 */
11986         0x08, 0x07
11987 };
11988
11989 static hda_nid_t alc268_adc_nids_alt[1] = {
11990         /* ADC0 */
11991         0x08
11992 };
11993
11994 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11995
11996 static struct snd_kcontrol_new alc268_base_mixer[] = {
11997         /* output mixer control */
11998         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11999         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12000         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12001         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12002         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12003         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12004         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12005         { }
12006 };
12007
12008 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12009         /* output mixer control */
12010         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12011         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12012         ALC262_HIPPO_MASTER_SWITCH,
12013         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12014         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12015         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12016         { }
12017 };
12018
12019 /* bind Beep switches of both NID 0x0f and 0x10 */
12020 static struct hda_bind_ctls alc268_bind_beep_sw = {
12021         .ops = &snd_hda_bind_sw,
12022         .values = {
12023                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12024                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12025                 0
12026         },
12027 };
12028
12029 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12030         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12031         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12032         { }
12033 };
12034
12035 static struct hda_verb alc268_eapd_verbs[] = {
12036         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12037         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12038         { }
12039 };
12040
12041 /* Toshiba specific */
12042 static struct hda_verb alc268_toshiba_verbs[] = {
12043         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12044         { } /* end */
12045 };
12046
12047 /* Acer specific */
12048 /* bind volumes of both NID 0x02 and 0x03 */
12049 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12050         .ops = &snd_hda_bind_vol,
12051         .values = {
12052                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12053                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12054                 0
12055         },
12056 };
12057
12058 /* mute/unmute internal speaker according to the hp jack and mute state */
12059 static void alc268_acer_automute(struct hda_codec *codec, int force)
12060 {
12061         struct alc_spec *spec = codec->spec;
12062         unsigned int mute;
12063
12064         if (force || !spec->sense_updated) {
12065                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12066                 spec->sense_updated = 1;
12067         }
12068         if (spec->jack_present)
12069                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12070         else /* unmute internal speaker if necessary */
12071                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12072         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12073                                  HDA_AMP_MUTE, mute);
12074 }
12075
12076
12077 /* bind hp and internal speaker mute (with plug check) */
12078 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12079                                      struct snd_ctl_elem_value *ucontrol)
12080 {
12081         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12082         long *valp = ucontrol->value.integer.value;
12083         int change;
12084
12085         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12086         if (change)
12087                 alc268_acer_automute(codec, 0);
12088         return change;
12089 }
12090
12091 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12092         /* output mixer control */
12093         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12094         {
12095                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12096                 .name = "Master Playback Switch",
12097                 .info = snd_hda_mixer_amp_switch_info,
12098                 .get = snd_hda_mixer_amp_switch_get,
12099                 .put = alc268_acer_master_sw_put,
12100                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12101         },
12102         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12103         { }
12104 };
12105
12106 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12107         /* output mixer control */
12108         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12109         {
12110                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12111                 .name = "Master Playback Switch",
12112                 .info = snd_hda_mixer_amp_switch_info,
12113                 .get = snd_hda_mixer_amp_switch_get,
12114                 .put = alc268_acer_master_sw_put,
12115                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12116         },
12117         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12118         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12119         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12120         { }
12121 };
12122
12123 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12124         /* output mixer control */
12125         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12126         {
12127                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12128                 .name = "Master Playback Switch",
12129                 .info = snd_hda_mixer_amp_switch_info,
12130                 .get = snd_hda_mixer_amp_switch_get,
12131                 .put = alc268_acer_master_sw_put,
12132                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12133         },
12134         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12135         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12136         { }
12137 };
12138
12139 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12140         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12141         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12142         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12143         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12144         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12145         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12146         { }
12147 };
12148
12149 static struct hda_verb alc268_acer_verbs[] = {
12150         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12151         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12152         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12153         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12154         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12155         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12156         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12157         { }
12158 };
12159
12160 /* unsolicited event for HP jack sensing */
12161 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12162 #define alc268_toshiba_setup            alc262_hippo_setup
12163 #define alc268_toshiba_automute         alc262_hippo_automute
12164
12165 static void alc268_acer_unsol_event(struct hda_codec *codec,
12166                                        unsigned int res)
12167 {
12168         if ((res >> 26) != ALC880_HP_EVENT)
12169                 return;
12170         alc268_acer_automute(codec, 1);
12171 }
12172
12173 static void alc268_acer_init_hook(struct hda_codec *codec)
12174 {
12175         alc268_acer_automute(codec, 1);
12176 }
12177
12178 /* toggle speaker-output according to the hp-jack state */
12179 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12180 {
12181         unsigned int present;
12182         unsigned char bits;
12183
12184         present = snd_hda_jack_detect(codec, 0x15);
12185         bits = present ? AMP_IN_MUTE(0) : 0;
12186         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12187                                 AMP_IN_MUTE(0), bits);
12188         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12189                                 AMP_IN_MUTE(0), bits);
12190 }
12191
12192 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12193                                     unsigned int res)
12194 {
12195         switch (res >> 26) {
12196         case ALC880_HP_EVENT:
12197                 alc268_aspire_one_speaker_automute(codec);
12198                 break;
12199         case ALC880_MIC_EVENT:
12200                 alc_mic_automute(codec);
12201                 break;
12202         }
12203 }
12204
12205 static void alc268_acer_lc_setup(struct hda_codec *codec)
12206 {
12207         struct alc_spec *spec = codec->spec;
12208         spec->ext_mic.pin = 0x18;
12209         spec->ext_mic.mux_idx = 0;
12210         spec->int_mic.pin = 0x12;
12211         spec->int_mic.mux_idx = 6;
12212         spec->auto_mic = 1;
12213 }
12214
12215 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12216 {
12217         alc268_aspire_one_speaker_automute(codec);
12218         alc_mic_automute(codec);
12219 }
12220
12221 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12222         /* output mixer control */
12223         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12224         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12225         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12226         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12227         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12228         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12229         { }
12230 };
12231
12232 static struct hda_verb alc268_dell_verbs[] = {
12233         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12234         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12235         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12236         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12237         { }
12238 };
12239
12240 /* mute/unmute internal speaker according to the hp jack and mute state */
12241 static void alc268_dell_setup(struct hda_codec *codec)
12242 {
12243         struct alc_spec *spec = codec->spec;
12244
12245         spec->autocfg.hp_pins[0] = 0x15;
12246         spec->autocfg.speaker_pins[0] = 0x14;
12247         spec->ext_mic.pin = 0x18;
12248         spec->ext_mic.mux_idx = 0;
12249         spec->int_mic.pin = 0x19;
12250         spec->int_mic.mux_idx = 1;
12251         spec->auto_mic = 1;
12252 }
12253
12254 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12255         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12256         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12257         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12258         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12259         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12260         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12261         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12262         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12263         { }
12264 };
12265
12266 static struct hda_verb alc267_quanta_il1_verbs[] = {
12267         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12268         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12269         { }
12270 };
12271
12272 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12273 {
12274         struct alc_spec *spec = codec->spec;
12275         spec->autocfg.hp_pins[0] = 0x15;
12276         spec->autocfg.speaker_pins[0] = 0x14;
12277         spec->ext_mic.pin = 0x18;
12278         spec->ext_mic.mux_idx = 0;
12279         spec->int_mic.pin = 0x19;
12280         spec->int_mic.mux_idx = 1;
12281         spec->auto_mic = 1;
12282 }
12283
12284 /*
12285  * generic initialization of ADC, input mixers and output mixers
12286  */
12287 static struct hda_verb alc268_base_init_verbs[] = {
12288         /* Unmute DAC0-1 and set vol = 0 */
12289         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12290         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12291
12292         /*
12293          * Set up output mixers (0x0c - 0x0e)
12294          */
12295         /* set vol=0 to output mixers */
12296         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12297         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12298
12299         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12300         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12301
12302         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12303         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12304         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12305         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12306         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12307         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12308         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12309         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12310
12311         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12313         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12315         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12316
12317         /* set PCBEEP vol = 0, mute connections */
12318         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12319         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12320         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12321
12322         /* Unmute Selector 23h,24h and set the default input to mic-in */
12323
12324         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12325         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12326         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12327         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12328
12329         { }
12330 };
12331
12332 /*
12333  * generic initialization of ADC, input mixers and output mixers
12334  */
12335 static struct hda_verb alc268_volume_init_verbs[] = {
12336         /* set output DAC */
12337         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12338         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12339
12340         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12341         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12342         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12343         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12344         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12345
12346         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12347         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12348         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12349
12350         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12351         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12352
12353         /* set PCBEEP vol = 0, mute connections */
12354         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12355         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12356         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12357
12358         { }
12359 };
12360
12361 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12362         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12363         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12364         { } /* end */
12365 };
12366
12367 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12368         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12369         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12370         _DEFINE_CAPSRC(1),
12371         { } /* end */
12372 };
12373
12374 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12375         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12376         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12377         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12378         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12379         _DEFINE_CAPSRC(2),
12380         { } /* end */
12381 };
12382
12383 static struct hda_input_mux alc268_capture_source = {
12384         .num_items = 4,
12385         .items = {
12386                 { "Mic", 0x0 },
12387                 { "Front Mic", 0x1 },
12388                 { "Line", 0x2 },
12389                 { "CD", 0x3 },
12390         },
12391 };
12392
12393 static struct hda_input_mux alc268_acer_capture_source = {
12394         .num_items = 3,
12395         .items = {
12396                 { "Mic", 0x0 },
12397                 { "Internal Mic", 0x1 },
12398                 { "Line", 0x2 },
12399         },
12400 };
12401
12402 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12403         .num_items = 3,
12404         .items = {
12405                 { "Mic", 0x0 },
12406                 { "Internal Mic", 0x6 },
12407                 { "Line", 0x2 },
12408         },
12409 };
12410
12411 #ifdef CONFIG_SND_DEBUG
12412 static struct snd_kcontrol_new alc268_test_mixer[] = {
12413         /* Volume widgets */
12414         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12415         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12416         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12417         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12418         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12419         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12420         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12421         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12422         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12423         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12424         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12425         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12426         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12427         /* The below appears problematic on some hardwares */
12428         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12429         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12430         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12431         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12432         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12433
12434         /* Modes for retasking pin widgets */
12435         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12436         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12437         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12438         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12439
12440         /* Controls for GPIO pins, assuming they are configured as outputs */
12441         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12442         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12443         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12444         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12445
12446         /* Switches to allow the digital SPDIF output pin to be enabled.
12447          * The ALC268 does not have an SPDIF input.
12448          */
12449         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12450
12451         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12452          * this output to turn on an external amplifier.
12453          */
12454         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12455         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12456
12457         { } /* end */
12458 };
12459 #endif
12460
12461 /* create input playback/capture controls for the given pin */
12462 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12463                                     const char *ctlname, int idx)
12464 {
12465         hda_nid_t dac;
12466         int err;
12467
12468         switch (nid) {
12469         case 0x14:
12470         case 0x16:
12471                 dac = 0x02;
12472                 break;
12473         case 0x15:
12474                 dac = 0x03;
12475                 break;
12476         default:
12477                 return 0;
12478         }
12479         if (spec->multiout.dac_nids[0] != dac &&
12480             spec->multiout.dac_nids[1] != dac) {
12481                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12482                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12483                                                       HDA_OUTPUT));
12484                 if (err < 0)
12485                         return err;
12486                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12487         }
12488
12489         if (nid != 0x16)
12490                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12491                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12492         else /* mono */
12493                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12494                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12495         if (err < 0)
12496                 return err;
12497         return 0;
12498 }
12499
12500 /* add playback controls from the parsed DAC table */
12501 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12502                                              const struct auto_pin_cfg *cfg)
12503 {
12504         hda_nid_t nid;
12505         int err;
12506
12507         spec->multiout.dac_nids = spec->private_dac_nids;
12508
12509         nid = cfg->line_out_pins[0];
12510         if (nid) {
12511                 const char *name;
12512                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12513                         name = "Speaker";
12514                 else
12515                         name = "Front";
12516                 err = alc268_new_analog_output(spec, nid, name, 0);
12517                 if (err < 0)
12518                         return err;
12519         }
12520
12521         nid = cfg->speaker_pins[0];
12522         if (nid == 0x1d) {
12523                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12524                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12525                 if (err < 0)
12526                         return err;
12527         } else {
12528                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12529                 if (err < 0)
12530                         return err;
12531         }
12532         nid = cfg->hp_pins[0];
12533         if (nid) {
12534                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12535                 if (err < 0)
12536                         return err;
12537         }
12538
12539         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12540         if (nid == 0x16) {
12541                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12542                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12543                 if (err < 0)
12544                         return err;
12545         }
12546         return 0;
12547 }
12548
12549 /* create playback/capture controls for input pins */
12550 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12551                                                 const struct auto_pin_cfg *cfg)
12552 {
12553         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12554 }
12555
12556 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12557                                               hda_nid_t nid, int pin_type)
12558 {
12559         int idx;
12560
12561         alc_set_pin_output(codec, nid, pin_type);
12562         if (nid == 0x14 || nid == 0x16)
12563                 idx = 0;
12564         else
12565                 idx = 1;
12566         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12567 }
12568
12569 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12570 {
12571         struct alc_spec *spec = codec->spec;
12572         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12573         if (nid) {
12574                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12575                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12576         }
12577 }
12578
12579 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12580 {
12581         struct alc_spec *spec = codec->spec;
12582         hda_nid_t pin;
12583
12584         pin = spec->autocfg.hp_pins[0];
12585         if (pin)
12586                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12587         pin = spec->autocfg.speaker_pins[0];
12588         if (pin)
12589                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12590 }
12591
12592 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12593 {
12594         struct alc_spec *spec = codec->spec;
12595         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12596         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12597         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12598         unsigned int    dac_vol1, dac_vol2;
12599
12600         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12601                 snd_hda_codec_write(codec, speaker_nid, 0,
12602                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12603                 /* mute mixer inputs from 0x1d */
12604                 snd_hda_codec_write(codec, 0x0f, 0,
12605                                     AC_VERB_SET_AMP_GAIN_MUTE,
12606                                     AMP_IN_UNMUTE(1));
12607                 snd_hda_codec_write(codec, 0x10, 0,
12608                                     AC_VERB_SET_AMP_GAIN_MUTE,
12609                                     AMP_IN_UNMUTE(1));
12610         } else {
12611                 /* unmute mixer inputs from 0x1d */
12612                 snd_hda_codec_write(codec, 0x0f, 0,
12613                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12614                 snd_hda_codec_write(codec, 0x10, 0,
12615                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12616         }
12617
12618         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12619         if (line_nid == 0x14)
12620                 dac_vol2 = AMP_OUT_ZERO;
12621         else if (line_nid == 0x15)
12622                 dac_vol1 = AMP_OUT_ZERO;
12623         if (hp_nid == 0x14)
12624                 dac_vol2 = AMP_OUT_ZERO;
12625         else if (hp_nid == 0x15)
12626                 dac_vol1 = AMP_OUT_ZERO;
12627         if (line_nid != 0x16 || hp_nid != 0x16 ||
12628             spec->autocfg.line_out_pins[1] != 0x16 ||
12629             spec->autocfg.line_out_pins[2] != 0x16)
12630                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12631
12632         snd_hda_codec_write(codec, 0x02, 0,
12633                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12634         snd_hda_codec_write(codec, 0x03, 0,
12635                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12636 }
12637
12638 /* pcm configuration: identical with ALC880 */
12639 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12640 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12641 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12642 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12643
12644 /*
12645  * BIOS auto configuration
12646  */
12647 static int alc268_parse_auto_config(struct hda_codec *codec)
12648 {
12649         struct alc_spec *spec = codec->spec;
12650         int err;
12651         static hda_nid_t alc268_ignore[] = { 0 };
12652
12653         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12654                                            alc268_ignore);
12655         if (err < 0)
12656                 return err;
12657         if (!spec->autocfg.line_outs) {
12658                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12659                         spec->multiout.max_channels = 2;
12660                         spec->no_analog = 1;
12661                         goto dig_only;
12662                 }
12663                 return 0; /* can't find valid BIOS pin config */
12664         }
12665         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12666         if (err < 0)
12667                 return err;
12668         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12669         if (err < 0)
12670                 return err;
12671
12672         spec->multiout.max_channels = 2;
12673
12674  dig_only:
12675         /* digital only support output */
12676         if (spec->autocfg.dig_outs) {
12677                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12678                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12679         }
12680         if (spec->kctls.list)
12681                 add_mixer(spec, spec->kctls.list);
12682
12683         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12684                 add_mixer(spec, alc268_beep_mixer);
12685
12686         add_verb(spec, alc268_volume_init_verbs);
12687         spec->num_mux_defs = 2;
12688         spec->input_mux = &spec->private_imux[0];
12689
12690         err = alc_auto_add_mic_boost(codec);
12691         if (err < 0)
12692                 return err;
12693
12694         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12695
12696         return 1;
12697 }
12698
12699 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12700
12701 /* init callback for auto-configuration model -- overriding the default init */
12702 static void alc268_auto_init(struct hda_codec *codec)
12703 {
12704         struct alc_spec *spec = codec->spec;
12705         alc268_auto_init_multi_out(codec);
12706         alc268_auto_init_hp_out(codec);
12707         alc268_auto_init_mono_speaker_out(codec);
12708         alc268_auto_init_analog_input(codec);
12709         if (spec->unsol_event)
12710                 alc_inithook(codec);
12711 }
12712
12713 /*
12714  * configuration and preset
12715  */
12716 static const char *alc268_models[ALC268_MODEL_LAST] = {
12717         [ALC267_QUANTA_IL1]     = "quanta-il1",
12718         [ALC268_3ST]            = "3stack",
12719         [ALC268_TOSHIBA]        = "toshiba",
12720         [ALC268_ACER]           = "acer",
12721         [ALC268_ACER_DMIC]      = "acer-dmic",
12722         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12723         [ALC268_DELL]           = "dell",
12724         [ALC268_ZEPTO]          = "zepto",
12725 #ifdef CONFIG_SND_DEBUG
12726         [ALC268_TEST]           = "test",
12727 #endif
12728         [ALC268_AUTO]           = "auto",
12729 };
12730
12731 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12732         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12733         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12734         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12735         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12736         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12737         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12738                                                 ALC268_ACER_ASPIRE_ONE),
12739         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12740         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
12741                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
12742         /* almost compatible with toshiba but with optional digital outs;
12743          * auto-probing seems working fine
12744          */
12745         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12746                            ALC268_AUTO),
12747         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12748         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12749         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12750         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12751         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12752         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12753         {}
12754 };
12755
12756 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12757 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12758         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12759         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12760         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12761                            ALC268_TOSHIBA),
12762         {}
12763 };
12764
12765 static struct alc_config_preset alc268_presets[] = {
12766         [ALC267_QUANTA_IL1] = {
12767                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12768                             alc268_capture_nosrc_mixer },
12769                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12770                                 alc267_quanta_il1_verbs },
12771                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12772                 .dac_nids = alc268_dac_nids,
12773                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12774                 .adc_nids = alc268_adc_nids_alt,
12775                 .hp_nid = 0x03,
12776                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12777                 .channel_mode = alc268_modes,
12778                 .unsol_event = alc_sku_unsol_event,
12779                 .setup = alc267_quanta_il1_setup,
12780                 .init_hook = alc_inithook,
12781         },
12782         [ALC268_3ST] = {
12783                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12784                             alc268_beep_mixer },
12785                 .init_verbs = { alc268_base_init_verbs },
12786                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12787                 .dac_nids = alc268_dac_nids,
12788                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12789                 .adc_nids = alc268_adc_nids_alt,
12790                 .capsrc_nids = alc268_capsrc_nids,
12791                 .hp_nid = 0x03,
12792                 .dig_out_nid = ALC268_DIGOUT_NID,
12793                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12794                 .channel_mode = alc268_modes,
12795                 .input_mux = &alc268_capture_source,
12796         },
12797         [ALC268_TOSHIBA] = {
12798                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12799                             alc268_beep_mixer },
12800                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12801                                 alc268_toshiba_verbs },
12802                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12803                 .dac_nids = alc268_dac_nids,
12804                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12805                 .adc_nids = alc268_adc_nids_alt,
12806                 .capsrc_nids = alc268_capsrc_nids,
12807                 .hp_nid = 0x03,
12808                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12809                 .channel_mode = alc268_modes,
12810                 .input_mux = &alc268_capture_source,
12811                 .unsol_event = alc268_toshiba_unsol_event,
12812                 .setup = alc268_toshiba_setup,
12813                 .init_hook = alc268_toshiba_automute,
12814         },
12815         [ALC268_ACER] = {
12816                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12817                             alc268_beep_mixer },
12818                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12819                                 alc268_acer_verbs },
12820                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12821                 .dac_nids = alc268_dac_nids,
12822                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12823                 .adc_nids = alc268_adc_nids_alt,
12824                 .capsrc_nids = alc268_capsrc_nids,
12825                 .hp_nid = 0x02,
12826                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12827                 .channel_mode = alc268_modes,
12828                 .input_mux = &alc268_acer_capture_source,
12829                 .unsol_event = alc268_acer_unsol_event,
12830                 .init_hook = alc268_acer_init_hook,
12831         },
12832         [ALC268_ACER_DMIC] = {
12833                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12834                             alc268_beep_mixer },
12835                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12836                                 alc268_acer_verbs },
12837                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12838                 .dac_nids = alc268_dac_nids,
12839                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12840                 .adc_nids = alc268_adc_nids_alt,
12841                 .capsrc_nids = alc268_capsrc_nids,
12842                 .hp_nid = 0x02,
12843                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12844                 .channel_mode = alc268_modes,
12845                 .input_mux = &alc268_acer_dmic_capture_source,
12846                 .unsol_event = alc268_acer_unsol_event,
12847                 .init_hook = alc268_acer_init_hook,
12848         },
12849         [ALC268_ACER_ASPIRE_ONE] = {
12850                 .mixers = { alc268_acer_aspire_one_mixer,
12851                             alc268_beep_mixer,
12852                             alc268_capture_nosrc_mixer },
12853                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12854                                 alc268_acer_aspire_one_verbs },
12855                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12856                 .dac_nids = alc268_dac_nids,
12857                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12858                 .adc_nids = alc268_adc_nids_alt,
12859                 .capsrc_nids = alc268_capsrc_nids,
12860                 .hp_nid = 0x03,
12861                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12862                 .channel_mode = alc268_modes,
12863                 .unsol_event = alc268_acer_lc_unsol_event,
12864                 .setup = alc268_acer_lc_setup,
12865                 .init_hook = alc268_acer_lc_init_hook,
12866         },
12867         [ALC268_DELL] = {
12868                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
12869                             alc268_capture_nosrc_mixer },
12870                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12871                                 alc268_dell_verbs },
12872                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12873                 .dac_nids = alc268_dac_nids,
12874                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12875                 .adc_nids = alc268_adc_nids_alt,
12876                 .capsrc_nids = alc268_capsrc_nids,
12877                 .hp_nid = 0x02,
12878                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12879                 .channel_mode = alc268_modes,
12880                 .unsol_event = alc_sku_unsol_event,
12881                 .setup = alc268_dell_setup,
12882                 .init_hook = alc_inithook,
12883         },
12884         [ALC268_ZEPTO] = {
12885                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12886                             alc268_beep_mixer },
12887                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12888                                 alc268_toshiba_verbs },
12889                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12890                 .dac_nids = alc268_dac_nids,
12891                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12892                 .adc_nids = alc268_adc_nids_alt,
12893                 .capsrc_nids = alc268_capsrc_nids,
12894                 .hp_nid = 0x03,
12895                 .dig_out_nid = ALC268_DIGOUT_NID,
12896                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12897                 .channel_mode = alc268_modes,
12898                 .input_mux = &alc268_capture_source,
12899                 .setup = alc268_toshiba_setup,
12900                 .init_hook = alc268_toshiba_automute,
12901         },
12902 #ifdef CONFIG_SND_DEBUG
12903         [ALC268_TEST] = {
12904                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12905                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12906                                 alc268_volume_init_verbs },
12907                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12908                 .dac_nids = alc268_dac_nids,
12909                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12910                 .adc_nids = alc268_adc_nids_alt,
12911                 .capsrc_nids = alc268_capsrc_nids,
12912                 .hp_nid = 0x03,
12913                 .dig_out_nid = ALC268_DIGOUT_NID,
12914                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12915                 .channel_mode = alc268_modes,
12916                 .input_mux = &alc268_capture_source,
12917         },
12918 #endif
12919 };
12920
12921 static int patch_alc268(struct hda_codec *codec)
12922 {
12923         struct alc_spec *spec;
12924         int board_config;
12925         int i, has_beep, err;
12926
12927         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12928         if (spec == NULL)
12929                 return -ENOMEM;
12930
12931         codec->spec = spec;
12932
12933         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12934                                                   alc268_models,
12935                                                   alc268_cfg_tbl);
12936
12937         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
12938                 board_config = snd_hda_check_board_codec_sid_config(codec,
12939                         ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
12940
12941         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12942                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12943                        codec->chip_name);
12944                 board_config = ALC268_AUTO;
12945         }
12946
12947         if (board_config == ALC268_AUTO) {
12948                 /* automatic parse from the BIOS config */
12949                 err = alc268_parse_auto_config(codec);
12950                 if (err < 0) {
12951                         alc_free(codec);
12952                         return err;
12953                 } else if (!err) {
12954                         printk(KERN_INFO
12955                                "hda_codec: Cannot set up configuration "
12956                                "from BIOS.  Using base mode...\n");
12957                         board_config = ALC268_3ST;
12958                 }
12959         }
12960
12961         if (board_config != ALC268_AUTO)
12962                 setup_preset(codec, &alc268_presets[board_config]);
12963
12964         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12965         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12966         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12967
12968         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12969
12970         has_beep = 0;
12971         for (i = 0; i < spec->num_mixers; i++) {
12972                 if (spec->mixers[i] == alc268_beep_mixer) {
12973                         has_beep = 1;
12974                         break;
12975                 }
12976         }
12977
12978         if (has_beep) {
12979                 err = snd_hda_attach_beep_device(codec, 0x1);
12980                 if (err < 0) {
12981                         alc_free(codec);
12982                         return err;
12983                 }
12984                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12985                         /* override the amp caps for beep generator */
12986                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12987                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12988                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12989                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12990                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12991         }
12992
12993         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12994                 /* check whether NID 0x07 is valid */
12995                 unsigned int wcap = get_wcaps(codec, 0x07);
12996                 int i;
12997
12998                 spec->capsrc_nids = alc268_capsrc_nids;
12999                 /* get type */
13000                 wcap = get_wcaps_type(wcap);
13001                 if (spec->auto_mic ||
13002                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13003                         spec->adc_nids = alc268_adc_nids_alt;
13004                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13005                         if (spec->auto_mic)
13006                                 fixup_automic_adc(codec);
13007                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13008                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13009                         else
13010                                 add_mixer(spec, alc268_capture_alt_mixer);
13011                 } else {
13012                         spec->adc_nids = alc268_adc_nids;
13013                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13014                         add_mixer(spec, alc268_capture_mixer);
13015                 }
13016                 /* set default input source */
13017                 for (i = 0; i < spec->num_adc_nids; i++)
13018                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13019                                 0, AC_VERB_SET_CONNECT_SEL,
13020                                 i < spec->num_mux_defs ?
13021                                 spec->input_mux[i].items[0].index :
13022                                 spec->input_mux->items[0].index);
13023         }
13024
13025         spec->vmaster_nid = 0x02;
13026
13027         codec->patch_ops = alc_patch_ops;
13028         if (board_config == ALC268_AUTO)
13029                 spec->init_hook = alc268_auto_init;
13030
13031         codec->proc_widget_hook = print_realtek_coef;
13032
13033         return 0;
13034 }
13035
13036 /*
13037  *  ALC269 channel source setting (2 channel)
13038  */
13039 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13040
13041 #define alc269_dac_nids         alc260_dac_nids
13042
13043 static hda_nid_t alc269_adc_nids[1] = {
13044         /* ADC1 */
13045         0x08,
13046 };
13047
13048 static hda_nid_t alc269_capsrc_nids[1] = {
13049         0x23,
13050 };
13051
13052 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
13053  *       not a mux!
13054  */
13055
13056 #define alc269_modes            alc260_modes
13057 #define alc269_capture_source   alc880_lg_lw_capture_source
13058
13059 static struct snd_kcontrol_new alc269_base_mixer[] = {
13060         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13061         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13062         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13063         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13064         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13065         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13066         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13067         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13068         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13069         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13070         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13071         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13072         { } /* end */
13073 };
13074
13075 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13076         /* output mixer control */
13077         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13078         {
13079                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13080                 .name = "Master Playback Switch",
13081                 .info = snd_hda_mixer_amp_switch_info,
13082                 .get = snd_hda_mixer_amp_switch_get,
13083                 .put = alc268_acer_master_sw_put,
13084                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13085         },
13086         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13087         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13088         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13089         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13090         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13091         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13092         { }
13093 };
13094
13095 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13096         /* output mixer control */
13097         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13098         {
13099                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13100                 .name = "Master Playback Switch",
13101                 .info = snd_hda_mixer_amp_switch_info,
13102                 .get = snd_hda_mixer_amp_switch_get,
13103                 .put = alc268_acer_master_sw_put,
13104                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13105         },
13106         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13107         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13108         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13109         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13110         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13111         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13112         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13113         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13114         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13115         { }
13116 };
13117
13118 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
13119         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13120         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13121         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13122         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13123         { } /* end */
13124 };
13125
13126 /* capture mixer elements */
13127 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
13128         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13129         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13130         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13131         { } /* end */
13132 };
13133
13134 /* FSC amilo */
13135 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
13136
13137 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13138         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13139         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13140         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13141         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13142         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13143         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13144         { }
13145 };
13146
13147 static struct hda_verb alc269_lifebook_verbs[] = {
13148         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13149         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13150         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13151         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13152         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13153         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13154         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13155         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13156         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13157         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13158         { }
13159 };
13160
13161 /* toggle speaker-output according to the hp-jack state */
13162 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13163 {
13164         unsigned int present;
13165         unsigned char bits;
13166
13167         present = snd_hda_jack_detect(codec, 0x15);
13168         bits = present ? AMP_IN_MUTE(0) : 0;
13169         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13170                         AMP_IN_MUTE(0), bits);
13171         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13172                         AMP_IN_MUTE(0), bits);
13173
13174         snd_hda_codec_write(codec, 0x20, 0,
13175                         AC_VERB_SET_COEF_INDEX, 0x0c);
13176         snd_hda_codec_write(codec, 0x20, 0,
13177                         AC_VERB_SET_PROC_COEF, 0x680);
13178
13179         snd_hda_codec_write(codec, 0x20, 0,
13180                         AC_VERB_SET_COEF_INDEX, 0x0c);
13181         snd_hda_codec_write(codec, 0x20, 0,
13182                         AC_VERB_SET_PROC_COEF, 0x480);
13183 }
13184
13185 /* toggle speaker-output according to the hp-jacks state */
13186 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13187 {
13188         unsigned int present;
13189         unsigned char bits;
13190
13191         /* Check laptop headphone socket */
13192         present = snd_hda_jack_detect(codec, 0x15);
13193
13194         /* Check port replicator headphone socket */
13195         present |= snd_hda_jack_detect(codec, 0x1a);
13196
13197         bits = present ? AMP_IN_MUTE(0) : 0;
13198         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13199                         AMP_IN_MUTE(0), bits);
13200         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13201                         AMP_IN_MUTE(0), bits);
13202
13203         snd_hda_codec_write(codec, 0x20, 0,
13204                         AC_VERB_SET_COEF_INDEX, 0x0c);
13205         snd_hda_codec_write(codec, 0x20, 0,
13206                         AC_VERB_SET_PROC_COEF, 0x680);
13207
13208         snd_hda_codec_write(codec, 0x20, 0,
13209                         AC_VERB_SET_COEF_INDEX, 0x0c);
13210         snd_hda_codec_write(codec, 0x20, 0,
13211                         AC_VERB_SET_PROC_COEF, 0x480);
13212 }
13213
13214 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13215 {
13216         unsigned int present_laptop;
13217         unsigned int present_dock;
13218
13219         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13220         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13221
13222         /* Laptop mic port overrides dock mic port, design decision */
13223         if (present_dock)
13224                 snd_hda_codec_write(codec, 0x23, 0,
13225                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13226         if (present_laptop)
13227                 snd_hda_codec_write(codec, 0x23, 0,
13228                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13229         if (!present_dock && !present_laptop)
13230                 snd_hda_codec_write(codec, 0x23, 0,
13231                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13232 }
13233
13234 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13235                                     unsigned int res)
13236 {
13237         switch (res >> 26) {
13238         case ALC880_HP_EVENT:
13239                 alc269_quanta_fl1_speaker_automute(codec);
13240                 break;
13241         case ALC880_MIC_EVENT:
13242                 alc_mic_automute(codec);
13243                 break;
13244         }
13245 }
13246
13247 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13248                                         unsigned int res)
13249 {
13250         if ((res >> 26) == ALC880_HP_EVENT)
13251                 alc269_lifebook_speaker_automute(codec);
13252         if ((res >> 26) == ALC880_MIC_EVENT)
13253                 alc269_lifebook_mic_autoswitch(codec);
13254 }
13255
13256 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13257 {
13258         struct alc_spec *spec = codec->spec;
13259         spec->ext_mic.pin = 0x18;
13260         spec->ext_mic.mux_idx = 0;
13261         spec->int_mic.pin = 0x19;
13262         spec->int_mic.mux_idx = 1;
13263         spec->auto_mic = 1;
13264 }
13265
13266 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13267 {
13268         alc269_quanta_fl1_speaker_automute(codec);
13269         alc_mic_automute(codec);
13270 }
13271
13272 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13273 {
13274         alc269_lifebook_speaker_automute(codec);
13275         alc269_lifebook_mic_autoswitch(codec);
13276 }
13277
13278 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13279         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13280         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13281         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13282         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13283         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13284         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13285         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13286         {}
13287 };
13288
13289 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13290         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13291         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13292         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13293         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13294         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13295         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13296         {}
13297 };
13298
13299 /* toggle speaker-output according to the hp-jack state */
13300 static void alc269_speaker_automute(struct hda_codec *codec)
13301 {
13302         struct alc_spec *spec = codec->spec;
13303         unsigned int nid = spec->autocfg.hp_pins[0];
13304         unsigned int present;
13305         unsigned char bits;
13306
13307         present = snd_hda_jack_detect(codec, nid);
13308         bits = present ? AMP_IN_MUTE(0) : 0;
13309         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13310                                 AMP_IN_MUTE(0), bits);
13311         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13312                                 AMP_IN_MUTE(0), bits);
13313 }
13314
13315 /* unsolicited event for HP jack sensing */
13316 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13317                                      unsigned int res)
13318 {
13319         switch (res >> 26) {
13320         case ALC880_HP_EVENT:
13321                 alc269_speaker_automute(codec);
13322                 break;
13323         case ALC880_MIC_EVENT:
13324                 alc_mic_automute(codec);
13325                 break;
13326         }
13327 }
13328
13329 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13330 {
13331         struct alc_spec *spec = codec->spec;
13332         spec->ext_mic.pin = 0x18;
13333         spec->ext_mic.mux_idx = 0;
13334         spec->int_mic.pin = 0x12;
13335         spec->int_mic.mux_idx = 5;
13336         spec->auto_mic = 1;
13337 }
13338
13339 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13340 {
13341         struct alc_spec *spec = codec->spec;
13342         spec->ext_mic.pin = 0x18;
13343         spec->ext_mic.mux_idx = 0;
13344         spec->int_mic.pin = 0x19;
13345         spec->int_mic.mux_idx = 1;
13346         spec->auto_mic = 1;
13347 }
13348
13349 static void alc269_eeepc_inithook(struct hda_codec *codec)
13350 {
13351         alc269_speaker_automute(codec);
13352         alc_mic_automute(codec);
13353 }
13354
13355 /*
13356  * generic initialization of ADC, input mixers and output mixers
13357  */
13358 static struct hda_verb alc269_init_verbs[] = {
13359         /*
13360          * Unmute ADC0 and set the default input to mic-in
13361          */
13362         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13363
13364         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13365          * analog-loopback mixer widget
13366          * Note: PASD motherboards uses the Line In 2 as the input for
13367          * front panel mic (mic 2)
13368          */
13369         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13370         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13371         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13372         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13373         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13374         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13375
13376         /*
13377          * Set up output mixers (0x0c - 0x0e)
13378          */
13379         /* set vol=0 to output mixers */
13380         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13381         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13382
13383         /* set up input amps for analog loopback */
13384         /* Amp Indices: DAC = 0, mixer = 1 */
13385         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13386         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13387         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13388         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13389         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13390         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13391
13392         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13393         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13394         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13395         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13396         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13397         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13398         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13399
13400         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13401         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13402         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13403         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13404         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13405         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13406         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13407
13408         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13409         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13410
13411         /* FIXME: use matrix-type input source selection */
13412         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13413         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13414         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13415         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13416         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13417         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13418
13419         /* set EAPD */
13420         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13421         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13422         { }
13423 };
13424
13425 #define alc269_auto_create_multi_out_ctls \
13426         alc268_auto_create_multi_out_ctls
13427 #define alc269_auto_create_input_ctls \
13428         alc268_auto_create_input_ctls
13429
13430 #ifdef CONFIG_SND_HDA_POWER_SAVE
13431 #define alc269_loopbacks        alc880_loopbacks
13432 #endif
13433
13434 /* pcm configuration: identical with ALC880 */
13435 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13436 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13437 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13438 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13439
13440 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13441         .substreams = 1,
13442         .channels_min = 2,
13443         .channels_max = 8,
13444         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13445         /* NID is set in alc_build_pcms */
13446         .ops = {
13447                 .open = alc880_playback_pcm_open,
13448                 .prepare = alc880_playback_pcm_prepare,
13449                 .cleanup = alc880_playback_pcm_cleanup
13450         },
13451 };
13452
13453 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13454         .substreams = 1,
13455         .channels_min = 2,
13456         .channels_max = 2,
13457         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13458         /* NID is set in alc_build_pcms */
13459 };
13460
13461 /*
13462  * BIOS auto configuration
13463  */
13464 static int alc269_parse_auto_config(struct hda_codec *codec)
13465 {
13466         struct alc_spec *spec = codec->spec;
13467         int err;
13468         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13469
13470         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13471                                            alc269_ignore);
13472         if (err < 0)
13473                 return err;
13474
13475         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13476         if (err < 0)
13477                 return err;
13478         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13479         if (err < 0)
13480                 return err;
13481
13482         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13483
13484         if (spec->autocfg.dig_outs)
13485                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13486
13487         if (spec->kctls.list)
13488                 add_mixer(spec, spec->kctls.list);
13489
13490         add_verb(spec, alc269_init_verbs);
13491         spec->num_mux_defs = 1;
13492         spec->input_mux = &spec->private_imux[0];
13493         /* set default input source */
13494         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13495                                   0, AC_VERB_SET_CONNECT_SEL,
13496                                   spec->input_mux->items[0].index);
13497
13498         err = alc_auto_add_mic_boost(codec);
13499         if (err < 0)
13500                 return err;
13501
13502         if (!spec->cap_mixer && !spec->no_analog)
13503                 set_capture_mixer(codec);
13504
13505         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13506
13507         return 1;
13508 }
13509
13510 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13511 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13512 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13513
13514
13515 /* init callback for auto-configuration model -- overriding the default init */
13516 static void alc269_auto_init(struct hda_codec *codec)
13517 {
13518         struct alc_spec *spec = codec->spec;
13519         alc269_auto_init_multi_out(codec);
13520         alc269_auto_init_hp_out(codec);
13521         alc269_auto_init_analog_input(codec);
13522         if (spec->unsol_event)
13523                 alc_inithook(codec);
13524 }
13525
13526 /*
13527  * configuration and preset
13528  */
13529 static const char *alc269_models[ALC269_MODEL_LAST] = {
13530         [ALC269_BASIC]                  = "basic",
13531         [ALC269_QUANTA_FL1]             = "quanta",
13532         [ALC269_ASUS_AMIC]              = "asus-amic",
13533         [ALC269_ASUS_DMIC]              = "asus-dmic",
13534         [ALC269_FUJITSU]                = "fujitsu",
13535         [ALC269_LIFEBOOK]               = "lifebook",
13536         [ALC269_AUTO]                   = "auto",
13537 };
13538
13539 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13540         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13541         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13542                       ALC269_ASUS_AMIC),
13543         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_ASUS_AMIC),
13544         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80JT", ALC269_ASUS_AMIC),
13545         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_ASUS_AMIC),
13546         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_ASUS_AMIC),
13547         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_ASUS_AMIC),
13548         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_ASUS_AMIC),
13549         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_ASUS_AMIC),
13550         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_ASUS_AMIC),
13551         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_ASUS_AMIC),
13552         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_ASUS_AMIC),
13553         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_ASUS_AMIC),
13554         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_ASUS_AMIC),
13555         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_ASUS_AMIC),
13556         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_ASUS_AMIC),
13557         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_ASUS_AMIC),
13558         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_ASUS_AMIC),
13559         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_ASUS_AMIC),
13560         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_ASUS_AMIC),
13561         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_ASUS_AMIC),
13562         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_ASUS_AMIC),
13563         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_AMIC),
13564         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_ASUS_AMIC),
13565         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_AMIC),
13566         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_DMIC),
13567         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_AMIC),
13568         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_AMIC),
13569         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_AMIC),
13570         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_AMIC),
13571         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13572                       ALC269_ASUS_DMIC),
13573         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13574                       ALC269_ASUS_DMIC),
13575         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_ASUS_DMIC),
13576         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_ASUS_DMIC),
13577         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13578         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13579         {}
13580 };
13581
13582 static struct alc_config_preset alc269_presets[] = {
13583         [ALC269_BASIC] = {
13584                 .mixers = { alc269_base_mixer },
13585                 .init_verbs = { alc269_init_verbs },
13586                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13587                 .dac_nids = alc269_dac_nids,
13588                 .hp_nid = 0x03,
13589                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13590                 .channel_mode = alc269_modes,
13591                 .input_mux = &alc269_capture_source,
13592         },
13593         [ALC269_QUANTA_FL1] = {
13594                 .mixers = { alc269_quanta_fl1_mixer },
13595                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13596                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13597                 .dac_nids = alc269_dac_nids,
13598                 .hp_nid = 0x03,
13599                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13600                 .channel_mode = alc269_modes,
13601                 .input_mux = &alc269_capture_source,
13602                 .unsol_event = alc269_quanta_fl1_unsol_event,
13603                 .setup = alc269_quanta_fl1_setup,
13604                 .init_hook = alc269_quanta_fl1_init_hook,
13605         },
13606         [ALC269_ASUS_AMIC] = {
13607                 .mixers = { alc269_eeepc_mixer },
13608                 .cap_mixer = alc269_epc_capture_mixer,
13609                 .init_verbs = { alc269_init_verbs,
13610                                 alc269_eeepc_amic_init_verbs },
13611                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13612                 .dac_nids = alc269_dac_nids,
13613                 .hp_nid = 0x03,
13614                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13615                 .channel_mode = alc269_modes,
13616                 .unsol_event = alc269_eeepc_unsol_event,
13617                 .setup = alc269_eeepc_amic_setup,
13618                 .init_hook = alc269_eeepc_inithook,
13619         },
13620         [ALC269_ASUS_DMIC] = {
13621                 .mixers = { alc269_eeepc_mixer },
13622                 .cap_mixer = alc269_epc_capture_mixer,
13623                 .init_verbs = { alc269_init_verbs,
13624                                 alc269_eeepc_dmic_init_verbs },
13625                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13626                 .dac_nids = alc269_dac_nids,
13627                 .hp_nid = 0x03,
13628                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13629                 .channel_mode = alc269_modes,
13630                 .unsol_event = alc269_eeepc_unsol_event,
13631                 .setup = alc269_eeepc_dmic_setup,
13632                 .init_hook = alc269_eeepc_inithook,
13633         },
13634         [ALC269_FUJITSU] = {
13635                 .mixers = { alc269_fujitsu_mixer },
13636                 .cap_mixer = alc269_epc_capture_mixer,
13637                 .init_verbs = { alc269_init_verbs,
13638                                 alc269_eeepc_dmic_init_verbs },
13639                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13640                 .dac_nids = alc269_dac_nids,
13641                 .hp_nid = 0x03,
13642                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13643                 .channel_mode = alc269_modes,
13644                 .unsol_event = alc269_eeepc_unsol_event,
13645                 .setup = alc269_eeepc_dmic_setup,
13646                 .init_hook = alc269_eeepc_inithook,
13647         },
13648         [ALC269_LIFEBOOK] = {
13649                 .mixers = { alc269_lifebook_mixer },
13650                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13651                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13652                 .dac_nids = alc269_dac_nids,
13653                 .hp_nid = 0x03,
13654                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13655                 .channel_mode = alc269_modes,
13656                 .input_mux = &alc269_capture_source,
13657                 .unsol_event = alc269_lifebook_unsol_event,
13658                 .init_hook = alc269_lifebook_init_hook,
13659         },
13660 };
13661
13662 static int patch_alc269(struct hda_codec *codec)
13663 {
13664         struct alc_spec *spec;
13665         int board_config;
13666         int err;
13667
13668         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13669         if (spec == NULL)
13670                 return -ENOMEM;
13671
13672         codec->spec = spec;
13673
13674         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13675
13676         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
13677                 kfree(codec->chip_name);
13678                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
13679                 if (!codec->chip_name) {
13680                         alc_free(codec);
13681                         return -ENOMEM;
13682                 }
13683         }
13684
13685         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13686                                                   alc269_models,
13687                                                   alc269_cfg_tbl);
13688
13689         if (board_config < 0) {
13690                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13691                        codec->chip_name);
13692                 board_config = ALC269_AUTO;
13693         }
13694
13695         if (board_config == ALC269_AUTO) {
13696                 /* automatic parse from the BIOS config */
13697                 err = alc269_parse_auto_config(codec);
13698                 if (err < 0) {
13699                         alc_free(codec);
13700                         return err;
13701                 } else if (!err) {
13702                         printk(KERN_INFO
13703                                "hda_codec: Cannot set up configuration "
13704                                "from BIOS.  Using base mode...\n");
13705                         board_config = ALC269_BASIC;
13706                 }
13707         }
13708
13709         err = snd_hda_attach_beep_device(codec, 0x1);
13710         if (err < 0) {
13711                 alc_free(codec);
13712                 return err;
13713         }
13714
13715         if (board_config != ALC269_AUTO)
13716                 setup_preset(codec, &alc269_presets[board_config]);
13717
13718         if (codec->subsystem_id == 0x17aa3bf8) {
13719                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13720                  * fix the sample rate of analog I/O to 44.1kHz
13721                  */
13722                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13723                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13724         } else {
13725                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13726                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13727         }
13728         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13729         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13730
13731         spec->adc_nids = alc269_adc_nids;
13732         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13733         spec->capsrc_nids = alc269_capsrc_nids;
13734         if (!spec->cap_mixer)
13735                 set_capture_mixer(codec);
13736         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13737
13738         spec->vmaster_nid = 0x02;
13739
13740         codec->patch_ops = alc_patch_ops;
13741         if (board_config == ALC269_AUTO)
13742                 spec->init_hook = alc269_auto_init;
13743 #ifdef CONFIG_SND_HDA_POWER_SAVE
13744         if (!spec->loopback.amplist)
13745                 spec->loopback.amplist = alc269_loopbacks;
13746 #endif
13747         codec->proc_widget_hook = print_realtek_coef;
13748
13749         return 0;
13750 }
13751
13752 /*
13753  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13754  */
13755
13756 /*
13757  * set the path ways for 2 channel output
13758  * need to set the codec line out and mic 1 pin widgets to inputs
13759  */
13760 static struct hda_verb alc861_threestack_ch2_init[] = {
13761         /* set pin widget 1Ah (line in) for input */
13762         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13763         /* set pin widget 18h (mic1/2) for input, for mic also enable
13764          * the vref
13765          */
13766         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13767
13768         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13769 #if 0
13770         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13771         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13772 #endif
13773         { } /* end */
13774 };
13775 /*
13776  * 6ch mode
13777  * need to set the codec line out and mic 1 pin widgets to outputs
13778  */
13779 static struct hda_verb alc861_threestack_ch6_init[] = {
13780         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13781         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13782         /* set pin widget 18h (mic1) for output (CLFE)*/
13783         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13784
13785         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13786         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13787
13788         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13789 #if 0
13790         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13791         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13792 #endif
13793         { } /* end */
13794 };
13795
13796 static struct hda_channel_mode alc861_threestack_modes[2] = {
13797         { 2, alc861_threestack_ch2_init },
13798         { 6, alc861_threestack_ch6_init },
13799 };
13800 /* Set mic1 as input and unmute the mixer */
13801 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13802         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13803         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13804         { } /* end */
13805 };
13806 /* Set mic1 as output and mute mixer */
13807 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13808         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13809         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13810         { } /* end */
13811 };
13812
13813 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13814         { 2, alc861_uniwill_m31_ch2_init },
13815         { 4, alc861_uniwill_m31_ch4_init },
13816 };
13817
13818 /* Set mic1 and line-in as input and unmute the mixer */
13819 static struct hda_verb alc861_asus_ch2_init[] = {
13820         /* set pin widget 1Ah (line in) for input */
13821         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13822         /* set pin widget 18h (mic1/2) for input, for mic also enable
13823          * the vref
13824          */
13825         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13826
13827         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13828 #if 0
13829         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13830         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13831 #endif
13832         { } /* end */
13833 };
13834 /* Set mic1 nad line-in as output and mute mixer */
13835 static struct hda_verb alc861_asus_ch6_init[] = {
13836         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13837         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13838         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13839         /* set pin widget 18h (mic1) for output (CLFE)*/
13840         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13841         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13842         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13843         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13844
13845         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13846 #if 0
13847         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13848         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13849 #endif
13850         { } /* end */
13851 };
13852
13853 static struct hda_channel_mode alc861_asus_modes[2] = {
13854         { 2, alc861_asus_ch2_init },
13855         { 6, alc861_asus_ch6_init },
13856 };
13857
13858 /* patch-ALC861 */
13859
13860 static struct snd_kcontrol_new alc861_base_mixer[] = {
13861         /* output mixer control */
13862         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13863         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13864         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13865         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13866         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13867
13868         /*Input mixer control */
13869         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13870            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13871         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13872         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13873         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13874         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13875         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13876         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13877         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13878         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13879
13880         { } /* end */
13881 };
13882
13883 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13884         /* output mixer control */
13885         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13886         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13887         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13888         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13889         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13890
13891         /* Input mixer control */
13892         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13893            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13894         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13895         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13896         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13897         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13899         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13900         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13901         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13902
13903         {
13904                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13905                 .name = "Channel Mode",
13906                 .info = alc_ch_mode_info,
13907                 .get = alc_ch_mode_get,
13908                 .put = alc_ch_mode_put,
13909                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13910         },
13911         { } /* end */
13912 };
13913
13914 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13915         /* output mixer control */
13916         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13917         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13918         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13919
13920         { } /* end */
13921 };
13922
13923 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13924         /* output mixer control */
13925         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13926         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13927         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13928         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13929         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13930
13931         /* Input mixer control */
13932         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13933            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13934         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13935         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13936         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13937         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13938         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13939         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13940         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13941         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13942
13943         {
13944                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13945                 .name = "Channel Mode",
13946                 .info = alc_ch_mode_info,
13947                 .get = alc_ch_mode_get,
13948                 .put = alc_ch_mode_put,
13949                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13950         },
13951         { } /* end */
13952 };
13953
13954 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13955         /* output mixer control */
13956         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13957         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13958         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13959         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13960         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13961
13962         /* Input mixer control */
13963         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13964         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13965         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13966         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13967         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13968         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13969         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13970         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13971         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13972         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13973
13974         {
13975                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13976                 .name = "Channel Mode",
13977                 .info = alc_ch_mode_info,
13978                 .get = alc_ch_mode_get,
13979                 .put = alc_ch_mode_put,
13980                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13981         },
13982         { }
13983 };
13984
13985 /* additional mixer */
13986 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13987         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13988         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13989         { }
13990 };
13991
13992 /*
13993  * generic initialization of ADC, input mixers and output mixers
13994  */
13995 static struct hda_verb alc861_base_init_verbs[] = {
13996         /*
13997          * Unmute ADC0 and set the default input to mic-in
13998          */
13999         /* port-A for surround (rear panel) */
14000         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14001         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14002         /* port-B for mic-in (rear panel) with vref */
14003         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14004         /* port-C for line-in (rear panel) */
14005         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14006         /* port-D for Front */
14007         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14008         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14009         /* port-E for HP out (front panel) */
14010         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14011         /* route front PCM to HP */
14012         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14013         /* port-F for mic-in (front panel) with vref */
14014         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14015         /* port-G for CLFE (rear panel) */
14016         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14017         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14018         /* port-H for side (rear panel) */
14019         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14020         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14021         /* CD-in */
14022         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14023         /* route front mic to ADC1*/
14024         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14025         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14026
14027         /* Unmute DAC0~3 & spdif out*/
14028         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14029         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14030         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14031         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14033
14034         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14035         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14036         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14037         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14038         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14039
14040         /* Unmute Stereo Mixer 15 */
14041         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14042         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14043         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14044         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14045
14046         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14047         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14048         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14049         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14050         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14051         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14052         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14053         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14054         /* hp used DAC 3 (Front) */
14055         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14056         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14057
14058         { }
14059 };
14060
14061 static struct hda_verb alc861_threestack_init_verbs[] = {
14062         /*
14063          * Unmute ADC0 and set the default input to mic-in
14064          */
14065         /* port-A for surround (rear panel) */
14066         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14067         /* port-B for mic-in (rear panel) with vref */
14068         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14069         /* port-C for line-in (rear panel) */
14070         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14071         /* port-D for Front */
14072         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14073         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14074         /* port-E for HP out (front panel) */
14075         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14076         /* route front PCM to HP */
14077         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14078         /* port-F for mic-in (front panel) with vref */
14079         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14080         /* port-G for CLFE (rear panel) */
14081         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14082         /* port-H for side (rear panel) */
14083         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14084         /* CD-in */
14085         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14086         /* route front mic to ADC1*/
14087         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14088         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14089         /* Unmute DAC0~3 & spdif out*/
14090         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14091         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14092         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14093         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14094         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14095
14096         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14097         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14098         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14099         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14100         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14101
14102         /* Unmute Stereo Mixer 15 */
14103         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14104         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14105         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14106         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14107
14108         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14109         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14110         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14111         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14112         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14113         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14114         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14115         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14116         /* hp used DAC 3 (Front) */
14117         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14118         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14119         { }
14120 };
14121
14122 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14123         /*
14124          * Unmute ADC0 and set the default input to mic-in
14125          */
14126         /* port-A for surround (rear panel) */
14127         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14128         /* port-B for mic-in (rear panel) with vref */
14129         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14130         /* port-C for line-in (rear panel) */
14131         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14132         /* port-D for Front */
14133         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14134         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14135         /* port-E for HP out (front panel) */
14136         /* this has to be set to VREF80 */
14137         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14138         /* route front PCM to HP */
14139         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14140         /* port-F for mic-in (front panel) with vref */
14141         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14142         /* port-G for CLFE (rear panel) */
14143         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14144         /* port-H for side (rear panel) */
14145         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14146         /* CD-in */
14147         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14148         /* route front mic to ADC1*/
14149         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14150         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14151         /* Unmute DAC0~3 & spdif out*/
14152         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14153         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14154         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14155         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14156         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14157
14158         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14159         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14160         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14161         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14162         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14163
14164         /* Unmute Stereo Mixer 15 */
14165         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14166         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14167         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14168         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14169
14170         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14171         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14172         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14173         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14174         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14175         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14176         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14177         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14178         /* hp used DAC 3 (Front) */
14179         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14180         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14181         { }
14182 };
14183
14184 static struct hda_verb alc861_asus_init_verbs[] = {
14185         /*
14186          * Unmute ADC0 and set the default input to mic-in
14187          */
14188         /* port-A for surround (rear panel)
14189          * according to codec#0 this is the HP jack
14190          */
14191         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14192         /* route front PCM to HP */
14193         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14194         /* port-B for mic-in (rear panel) with vref */
14195         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14196         /* port-C for line-in (rear panel) */
14197         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14198         /* port-D for Front */
14199         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14200         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14201         /* port-E for HP out (front panel) */
14202         /* this has to be set to VREF80 */
14203         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14204         /* route front PCM to HP */
14205         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14206         /* port-F for mic-in (front panel) with vref */
14207         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14208         /* port-G for CLFE (rear panel) */
14209         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14210         /* port-H for side (rear panel) */
14211         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14212         /* CD-in */
14213         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14214         /* route front mic to ADC1*/
14215         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14216         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14217         /* Unmute DAC0~3 & spdif out*/
14218         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14219         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14220         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14221         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14222         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14223         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14224         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14225         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14226         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14227         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14228
14229         /* Unmute Stereo Mixer 15 */
14230         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14231         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14232         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14233         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14234
14235         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14236         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14237         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14238         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14239         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14240         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14241         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14242         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14243         /* hp used DAC 3 (Front) */
14244         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14245         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14246         { }
14247 };
14248
14249 /* additional init verbs for ASUS laptops */
14250 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14251         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14252         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14253         { }
14254 };
14255
14256 /*
14257  * generic initialization of ADC, input mixers and output mixers
14258  */
14259 static struct hda_verb alc861_auto_init_verbs[] = {
14260         /*
14261          * Unmute ADC0 and set the default input to mic-in
14262          */
14263         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14264         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14265
14266         /* Unmute DAC0~3 & spdif out*/
14267         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14268         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14269         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14270         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14271         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14272
14273         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14274         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14275         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14276         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14277         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14278
14279         /* Unmute Stereo Mixer 15 */
14280         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14281         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14282         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14283         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14284
14285         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14286         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14287         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14288         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14289         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14290         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14291         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14292         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14293
14294         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14295         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14296         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14297         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14298         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14299         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14300         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14301         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14302
14303         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14304
14305         { }
14306 };
14307
14308 static struct hda_verb alc861_toshiba_init_verbs[] = {
14309         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14310
14311         { }
14312 };
14313
14314 /* toggle speaker-output according to the hp-jack state */
14315 static void alc861_toshiba_automute(struct hda_codec *codec)
14316 {
14317         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14318
14319         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14320                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14321         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14322                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14323 }
14324
14325 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14326                                        unsigned int res)
14327 {
14328         if ((res >> 26) == ALC880_HP_EVENT)
14329                 alc861_toshiba_automute(codec);
14330 }
14331
14332 /* pcm configuration: identical with ALC880 */
14333 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14334 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14335 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14336 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14337
14338
14339 #define ALC861_DIGOUT_NID       0x07
14340
14341 static struct hda_channel_mode alc861_8ch_modes[1] = {
14342         { 8, NULL }
14343 };
14344
14345 static hda_nid_t alc861_dac_nids[4] = {
14346         /* front, surround, clfe, side */
14347         0x03, 0x06, 0x05, 0x04
14348 };
14349
14350 static hda_nid_t alc660_dac_nids[3] = {
14351         /* front, clfe, surround */
14352         0x03, 0x05, 0x06
14353 };
14354
14355 static hda_nid_t alc861_adc_nids[1] = {
14356         /* ADC0-2 */
14357         0x08,
14358 };
14359
14360 static struct hda_input_mux alc861_capture_source = {
14361         .num_items = 5,
14362         .items = {
14363                 { "Mic", 0x0 },
14364                 { "Front Mic", 0x3 },
14365                 { "Line", 0x1 },
14366                 { "CD", 0x4 },
14367                 { "Mixer", 0x5 },
14368         },
14369 };
14370
14371 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14372 {
14373         struct alc_spec *spec = codec->spec;
14374         hda_nid_t mix, srcs[5];
14375         int i, j, num;
14376
14377         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14378                 return 0;
14379         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14380         if (num < 0)
14381                 return 0;
14382         for (i = 0; i < num; i++) {
14383                 unsigned int type;
14384                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14385                 if (type != AC_WID_AUD_OUT)
14386                         continue;
14387                 for (j = 0; j < spec->multiout.num_dacs; j++)
14388                         if (spec->multiout.dac_nids[j] == srcs[i])
14389                                 break;
14390                 if (j >= spec->multiout.num_dacs)
14391                         return srcs[i];
14392         }
14393         return 0;
14394 }
14395
14396 /* fill in the dac_nids table from the parsed pin configuration */
14397 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14398                                      const struct auto_pin_cfg *cfg)
14399 {
14400         struct alc_spec *spec = codec->spec;
14401         int i;
14402         hda_nid_t nid, dac;
14403
14404         spec->multiout.dac_nids = spec->private_dac_nids;
14405         for (i = 0; i < cfg->line_outs; i++) {
14406                 nid = cfg->line_out_pins[i];
14407                 dac = alc861_look_for_dac(codec, nid);
14408                 if (!dac)
14409                         continue;
14410                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14411         }
14412         return 0;
14413 }
14414
14415 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14416                                 hda_nid_t nid, unsigned int chs)
14417 {
14418         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14419                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14420 }
14421
14422 /* add playback controls from the parsed DAC table */
14423 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14424                                              const struct auto_pin_cfg *cfg)
14425 {
14426         struct alc_spec *spec = codec->spec;
14427         static const char *chname[4] = {
14428                 "Front", "Surround", NULL /*CLFE*/, "Side"
14429         };
14430         hda_nid_t nid;
14431         int i, err;
14432
14433         if (cfg->line_outs == 1) {
14434                 const char *pfx = NULL;
14435                 if (!cfg->hp_outs)
14436                         pfx = "Master";
14437                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14438                         pfx = "Speaker";
14439                 if (pfx) {
14440                         nid = spec->multiout.dac_nids[0];
14441                         return alc861_create_out_sw(codec, pfx, nid, 3);
14442                 }
14443         }
14444
14445         for (i = 0; i < cfg->line_outs; i++) {
14446                 nid = spec->multiout.dac_nids[i];
14447                 if (!nid)
14448                         continue;
14449                 if (i == 2) {
14450                         /* Center/LFE */
14451                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14452                         if (err < 0)
14453                                 return err;
14454                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14455                         if (err < 0)
14456                                 return err;
14457                 } else {
14458                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14459                         if (err < 0)
14460                                 return err;
14461                 }
14462         }
14463         return 0;
14464 }
14465
14466 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14467 {
14468         struct alc_spec *spec = codec->spec;
14469         int err;
14470         hda_nid_t nid;
14471
14472         if (!pin)
14473                 return 0;
14474
14475         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14476                 nid = alc861_look_for_dac(codec, pin);
14477                 if (nid) {
14478                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14479                         if (err < 0)
14480                                 return err;
14481                         spec->multiout.hp_nid = nid;
14482                 }
14483         }
14484         return 0;
14485 }
14486
14487 /* create playback/capture controls for input pins */
14488 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14489                                                 const struct auto_pin_cfg *cfg)
14490 {
14491         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14492 }
14493
14494 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14495                                               hda_nid_t nid,
14496                                               int pin_type, hda_nid_t dac)
14497 {
14498         hda_nid_t mix, srcs[5];
14499         int i, num;
14500
14501         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14502                             pin_type);
14503         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14504                             AMP_OUT_UNMUTE);
14505         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14506                 return;
14507         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14508         if (num < 0)
14509                 return;
14510         for (i = 0; i < num; i++) {
14511                 unsigned int mute;
14512                 if (srcs[i] == dac || srcs[i] == 0x15)
14513                         mute = AMP_IN_UNMUTE(i);
14514                 else
14515                         mute = AMP_IN_MUTE(i);
14516                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14517                                     mute);
14518         }
14519 }
14520
14521 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14522 {
14523         struct alc_spec *spec = codec->spec;
14524         int i;
14525
14526         for (i = 0; i < spec->autocfg.line_outs; i++) {
14527                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14528                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14529                 if (nid)
14530                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14531                                                           spec->multiout.dac_nids[i]);
14532         }
14533 }
14534
14535 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14536 {
14537         struct alc_spec *spec = codec->spec;
14538
14539         if (spec->autocfg.hp_outs)
14540                 alc861_auto_set_output_and_unmute(codec,
14541                                                   spec->autocfg.hp_pins[0],
14542                                                   PIN_HP,
14543                                                   spec->multiout.hp_nid);
14544         if (spec->autocfg.speaker_outs)
14545                 alc861_auto_set_output_and_unmute(codec,
14546                                                   spec->autocfg.speaker_pins[0],
14547                                                   PIN_OUT,
14548                                                   spec->multiout.dac_nids[0]);
14549 }
14550
14551 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14552 {
14553         struct alc_spec *spec = codec->spec;
14554         int i;
14555
14556         for (i = 0; i < AUTO_PIN_LAST; i++) {
14557                 hda_nid_t nid = spec->autocfg.input_pins[i];
14558                 if (nid >= 0x0c && nid <= 0x11)
14559                         alc_set_input_pin(codec, nid, i);
14560         }
14561 }
14562
14563 /* parse the BIOS configuration and set up the alc_spec */
14564 /* return 1 if successful, 0 if the proper config is not found,
14565  * or a negative error code
14566  */
14567 static int alc861_parse_auto_config(struct hda_codec *codec)
14568 {
14569         struct alc_spec *spec = codec->spec;
14570         int err;
14571         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14572
14573         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14574                                            alc861_ignore);
14575         if (err < 0)
14576                 return err;
14577         if (!spec->autocfg.line_outs)
14578                 return 0; /* can't find valid BIOS pin config */
14579
14580         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14581         if (err < 0)
14582                 return err;
14583         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14584         if (err < 0)
14585                 return err;
14586         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14587         if (err < 0)
14588                 return err;
14589         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14590         if (err < 0)
14591                 return err;
14592
14593         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14594
14595         if (spec->autocfg.dig_outs)
14596                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14597
14598         if (spec->kctls.list)
14599                 add_mixer(spec, spec->kctls.list);
14600
14601         add_verb(spec, alc861_auto_init_verbs);
14602
14603         spec->num_mux_defs = 1;
14604         spec->input_mux = &spec->private_imux[0];
14605
14606         spec->adc_nids = alc861_adc_nids;
14607         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14608         set_capture_mixer(codec);
14609
14610         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14611
14612         return 1;
14613 }
14614
14615 /* additional initialization for auto-configuration model */
14616 static void alc861_auto_init(struct hda_codec *codec)
14617 {
14618         struct alc_spec *spec = codec->spec;
14619         alc861_auto_init_multi_out(codec);
14620         alc861_auto_init_hp_out(codec);
14621         alc861_auto_init_analog_input(codec);
14622         if (spec->unsol_event)
14623                 alc_inithook(codec);
14624 }
14625
14626 #ifdef CONFIG_SND_HDA_POWER_SAVE
14627 static struct hda_amp_list alc861_loopbacks[] = {
14628         { 0x15, HDA_INPUT, 0 },
14629         { 0x15, HDA_INPUT, 1 },
14630         { 0x15, HDA_INPUT, 2 },
14631         { 0x15, HDA_INPUT, 3 },
14632         { } /* end */
14633 };
14634 #endif
14635
14636
14637 /*
14638  * configuration and preset
14639  */
14640 static const char *alc861_models[ALC861_MODEL_LAST] = {
14641         [ALC861_3ST]            = "3stack",
14642         [ALC660_3ST]            = "3stack-660",
14643         [ALC861_3ST_DIG]        = "3stack-dig",
14644         [ALC861_6ST_DIG]        = "6stack-dig",
14645         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14646         [ALC861_TOSHIBA]        = "toshiba",
14647         [ALC861_ASUS]           = "asus",
14648         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14649         [ALC861_AUTO]           = "auto",
14650 };
14651
14652 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14653         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14654         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14655         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14656         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14657         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14658         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14659         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14660         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14661          *        Any other models that need this preset?
14662          */
14663         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14664         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14665         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14666         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14667         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14668         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14669         /* FIXME: the below seems conflict */
14670         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14671         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14672         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14673         {}
14674 };
14675
14676 static struct alc_config_preset alc861_presets[] = {
14677         [ALC861_3ST] = {
14678                 .mixers = { alc861_3ST_mixer },
14679                 .init_verbs = { alc861_threestack_init_verbs },
14680                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14681                 .dac_nids = alc861_dac_nids,
14682                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14683                 .channel_mode = alc861_threestack_modes,
14684                 .need_dac_fix = 1,
14685                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14686                 .adc_nids = alc861_adc_nids,
14687                 .input_mux = &alc861_capture_source,
14688         },
14689         [ALC861_3ST_DIG] = {
14690                 .mixers = { alc861_base_mixer },
14691                 .init_verbs = { alc861_threestack_init_verbs },
14692                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14693                 .dac_nids = alc861_dac_nids,
14694                 .dig_out_nid = ALC861_DIGOUT_NID,
14695                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14696                 .channel_mode = alc861_threestack_modes,
14697                 .need_dac_fix = 1,
14698                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14699                 .adc_nids = alc861_adc_nids,
14700                 .input_mux = &alc861_capture_source,
14701         },
14702         [ALC861_6ST_DIG] = {
14703                 .mixers = { alc861_base_mixer },
14704                 .init_verbs = { alc861_base_init_verbs },
14705                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14706                 .dac_nids = alc861_dac_nids,
14707                 .dig_out_nid = ALC861_DIGOUT_NID,
14708                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14709                 .channel_mode = alc861_8ch_modes,
14710                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14711                 .adc_nids = alc861_adc_nids,
14712                 .input_mux = &alc861_capture_source,
14713         },
14714         [ALC660_3ST] = {
14715                 .mixers = { alc861_3ST_mixer },
14716                 .init_verbs = { alc861_threestack_init_verbs },
14717                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14718                 .dac_nids = alc660_dac_nids,
14719                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14720                 .channel_mode = alc861_threestack_modes,
14721                 .need_dac_fix = 1,
14722                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14723                 .adc_nids = alc861_adc_nids,
14724                 .input_mux = &alc861_capture_source,
14725         },
14726         [ALC861_UNIWILL_M31] = {
14727                 .mixers = { alc861_uniwill_m31_mixer },
14728                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14729                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14730                 .dac_nids = alc861_dac_nids,
14731                 .dig_out_nid = ALC861_DIGOUT_NID,
14732                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14733                 .channel_mode = alc861_uniwill_m31_modes,
14734                 .need_dac_fix = 1,
14735                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14736                 .adc_nids = alc861_adc_nids,
14737                 .input_mux = &alc861_capture_source,
14738         },
14739         [ALC861_TOSHIBA] = {
14740                 .mixers = { alc861_toshiba_mixer },
14741                 .init_verbs = { alc861_base_init_verbs,
14742                                 alc861_toshiba_init_verbs },
14743                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14744                 .dac_nids = alc861_dac_nids,
14745                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14746                 .channel_mode = alc883_3ST_2ch_modes,
14747                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14748                 .adc_nids = alc861_adc_nids,
14749                 .input_mux = &alc861_capture_source,
14750                 .unsol_event = alc861_toshiba_unsol_event,
14751                 .init_hook = alc861_toshiba_automute,
14752         },
14753         [ALC861_ASUS] = {
14754                 .mixers = { alc861_asus_mixer },
14755                 .init_verbs = { alc861_asus_init_verbs },
14756                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14757                 .dac_nids = alc861_dac_nids,
14758                 .dig_out_nid = ALC861_DIGOUT_NID,
14759                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14760                 .channel_mode = alc861_asus_modes,
14761                 .need_dac_fix = 1,
14762                 .hp_nid = 0x06,
14763                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14764                 .adc_nids = alc861_adc_nids,
14765                 .input_mux = &alc861_capture_source,
14766         },
14767         [ALC861_ASUS_LAPTOP] = {
14768                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14769                 .init_verbs = { alc861_asus_init_verbs,
14770                                 alc861_asus_laptop_init_verbs },
14771                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14772                 .dac_nids = alc861_dac_nids,
14773                 .dig_out_nid = ALC861_DIGOUT_NID,
14774                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14775                 .channel_mode = alc883_3ST_2ch_modes,
14776                 .need_dac_fix = 1,
14777                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14778                 .adc_nids = alc861_adc_nids,
14779                 .input_mux = &alc861_capture_source,
14780         },
14781 };
14782
14783 /* Pin config fixes */
14784 enum {
14785         PINFIX_FSC_AMILO_PI1505,
14786 };
14787
14788 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
14789         { 0x0b, 0x0221101f }, /* HP */
14790         { 0x0f, 0x90170310 }, /* speaker */
14791         { }
14792 };
14793
14794 static const struct alc_fixup alc861_fixups[] = {
14795         [PINFIX_FSC_AMILO_PI1505] = {
14796                 .pins = alc861_fsc_amilo_pi1505_pinfix
14797         },
14798 };
14799
14800 static struct snd_pci_quirk alc861_fixup_tbl[] = {
14801         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
14802         {}
14803 };
14804
14805 static int patch_alc861(struct hda_codec *codec)
14806 {
14807         struct alc_spec *spec;
14808         int board_config;
14809         int err;
14810
14811         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14812         if (spec == NULL)
14813                 return -ENOMEM;
14814
14815         codec->spec = spec;
14816
14817         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14818                                                   alc861_models,
14819                                                   alc861_cfg_tbl);
14820
14821         if (board_config < 0) {
14822                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14823                        codec->chip_name);
14824                 board_config = ALC861_AUTO;
14825         }
14826
14827         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
14828
14829         if (board_config == ALC861_AUTO) {
14830                 /* automatic parse from the BIOS config */
14831                 err = alc861_parse_auto_config(codec);
14832                 if (err < 0) {
14833                         alc_free(codec);
14834                         return err;
14835                 } else if (!err) {
14836                         printk(KERN_INFO
14837                                "hda_codec: Cannot set up configuration "
14838                                "from BIOS.  Using base mode...\n");
14839                    board_config = ALC861_3ST_DIG;
14840                 }
14841         }
14842
14843         err = snd_hda_attach_beep_device(codec, 0x23);
14844         if (err < 0) {
14845                 alc_free(codec);
14846                 return err;
14847         }
14848
14849         if (board_config != ALC861_AUTO)
14850                 setup_preset(codec, &alc861_presets[board_config]);
14851
14852         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14853         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14854
14855         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14856         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14857
14858         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14859
14860         spec->vmaster_nid = 0x03;
14861
14862         codec->patch_ops = alc_patch_ops;
14863         if (board_config == ALC861_AUTO)
14864                 spec->init_hook = alc861_auto_init;
14865 #ifdef CONFIG_SND_HDA_POWER_SAVE
14866         if (!spec->loopback.amplist)
14867                 spec->loopback.amplist = alc861_loopbacks;
14868 #endif
14869         codec->proc_widget_hook = print_realtek_coef;
14870
14871         return 0;
14872 }
14873
14874 /*
14875  * ALC861-VD support
14876  *
14877  * Based on ALC882
14878  *
14879  * In addition, an independent DAC
14880  */
14881 #define ALC861VD_DIGOUT_NID     0x06
14882
14883 static hda_nid_t alc861vd_dac_nids[4] = {
14884         /* front, surr, clfe, side surr */
14885         0x02, 0x03, 0x04, 0x05
14886 };
14887
14888 /* dac_nids for ALC660vd are in a different order - according to
14889  * Realtek's driver.
14890  * This should probably result in a different mixer for 6stack models
14891  * of ALC660vd codecs, but for now there is only 3stack mixer
14892  * - and it is the same as in 861vd.
14893  * adc_nids in ALC660vd are (is) the same as in 861vd
14894  */
14895 static hda_nid_t alc660vd_dac_nids[3] = {
14896         /* front, rear, clfe, rear_surr */
14897         0x02, 0x04, 0x03
14898 };
14899
14900 static hda_nid_t alc861vd_adc_nids[1] = {
14901         /* ADC0 */
14902         0x09,
14903 };
14904
14905 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14906
14907 /* input MUX */
14908 /* FIXME: should be a matrix-type input source selection */
14909 static struct hda_input_mux alc861vd_capture_source = {
14910         .num_items = 4,
14911         .items = {
14912                 { "Mic", 0x0 },
14913                 { "Front Mic", 0x1 },
14914                 { "Line", 0x2 },
14915                 { "CD", 0x4 },
14916         },
14917 };
14918
14919 static struct hda_input_mux alc861vd_dallas_capture_source = {
14920         .num_items = 2,
14921         .items = {
14922                 { "Ext Mic", 0x0 },
14923                 { "Int Mic", 0x1 },
14924         },
14925 };
14926
14927 static struct hda_input_mux alc861vd_hp_capture_source = {
14928         .num_items = 2,
14929         .items = {
14930                 { "Front Mic", 0x0 },
14931                 { "ATAPI Mic", 0x1 },
14932         },
14933 };
14934
14935 /*
14936  * 2ch mode
14937  */
14938 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14939         { 2, NULL }
14940 };
14941
14942 /*
14943  * 6ch mode
14944  */
14945 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14946         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14947         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14948         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14949         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14950         { } /* end */
14951 };
14952
14953 /*
14954  * 8ch mode
14955  */
14956 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14957         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14958         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14959         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14960         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14961         { } /* end */
14962 };
14963
14964 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14965         { 6, alc861vd_6stack_ch6_init },
14966         { 8, alc861vd_6stack_ch8_init },
14967 };
14968
14969 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14970         {
14971                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14972                 .name = "Channel Mode",
14973                 .info = alc_ch_mode_info,
14974                 .get = alc_ch_mode_get,
14975                 .put = alc_ch_mode_put,
14976         },
14977         { } /* end */
14978 };
14979
14980 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14981  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14982  */
14983 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14984         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14985         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14986
14987         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14988         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14989
14990         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14991                                 HDA_OUTPUT),
14992         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14993                                 HDA_OUTPUT),
14994         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14995         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14996
14997         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14998         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14999
15000         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15001
15002         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15003         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15004         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15005
15006         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15007         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15008         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15009
15010         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15011         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15012
15013         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15014         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15015
15016         { } /* end */
15017 };
15018
15019 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15020         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15021         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15022
15023         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15024
15025         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15026         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15027         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15028
15029         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15030         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15031         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15032
15033         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15034         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15035
15036         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15037         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15038
15039         { } /* end */
15040 };
15041
15042 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15043         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15044         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15045         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15046
15047         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15048
15049         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15050         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15051         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15052
15053         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15054         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15055         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15056
15057         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15058         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15059
15060         { } /* end */
15061 };
15062
15063 /* Pin assignment: Speaker=0x14, HP = 0x15,
15064  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15065  */
15066 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15067         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15068         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15069         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15070         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15071         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15072         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15073         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15074         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15075         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15076         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15077         { } /* end */
15078 };
15079
15080 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15081  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15082  */
15083 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15084         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15085         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15086         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15087         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15088         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15089         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15090         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15091         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15092
15093         { } /* end */
15094 };
15095
15096 /*
15097  * generic initialization of ADC, input mixers and output mixers
15098  */
15099 static struct hda_verb alc861vd_volume_init_verbs[] = {
15100         /*
15101          * Unmute ADC0 and set the default input to mic-in
15102          */
15103         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15104         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15105
15106         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15107          * the analog-loopback mixer widget
15108          */
15109         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15110         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15111         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15115
15116         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15117         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15118         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15119         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15120         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15121
15122         /*
15123          * Set up output mixers (0x02 - 0x05)
15124          */
15125         /* set vol=0 to output mixers */
15126         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15127         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15128         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15129         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15130
15131         /* set up input amps for analog loopback */
15132         /* Amp Indices: DAC = 0, mixer = 1 */
15133         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15134         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15135         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15136         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15137         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15138         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15139         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15140         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15141
15142         { }
15143 };
15144
15145 /*
15146  * 3-stack pin configuration:
15147  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15148  */
15149 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15150         /*
15151          * Set pin mode and muting
15152          */
15153         /* set front pin widgets 0x14 for output */
15154         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15155         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15156         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15157
15158         /* Mic (rear) pin: input vref at 80% */
15159         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15160         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15161         /* Front Mic pin: input vref at 80% */
15162         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15163         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15164         /* Line In pin: input */
15165         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15166         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15167         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15168         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15169         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15170         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15171         /* CD pin widget for input */
15172         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15173
15174         { }
15175 };
15176
15177 /*
15178  * 6-stack pin configuration:
15179  */
15180 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15181         /*
15182          * Set pin mode and muting
15183          */
15184         /* set front pin widgets 0x14 for output */
15185         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15186         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15187         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15188
15189         /* Rear Pin: output 1 (0x0d) */
15190         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15191         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15192         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15193         /* CLFE Pin: output 2 (0x0e) */
15194         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15195         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15196         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15197         /* Side Pin: output 3 (0x0f) */
15198         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15199         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15200         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15201
15202         /* Mic (rear) pin: input vref at 80% */
15203         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15204         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15205         /* Front Mic pin: input vref at 80% */
15206         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15207         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15208         /* Line In pin: input */
15209         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15210         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15211         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15212         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15213         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15214         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15215         /* CD pin widget for input */
15216         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15217
15218         { }
15219 };
15220
15221 static struct hda_verb alc861vd_eapd_verbs[] = {
15222         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15223         { }
15224 };
15225
15226 static struct hda_verb alc660vd_eapd_verbs[] = {
15227         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15228         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15229         { }
15230 };
15231
15232 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15233         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15235         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15236         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15237         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15238         {}
15239 };
15240
15241 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15242 {
15243         unsigned int present;
15244         unsigned char bits;
15245
15246         present = snd_hda_jack_detect(codec, 0x18);
15247         bits = present ? HDA_AMP_MUTE : 0;
15248
15249         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15250                                  HDA_AMP_MUTE, bits);
15251 }
15252
15253 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15254 {
15255         struct alc_spec *spec = codec->spec;
15256         spec->autocfg.hp_pins[0] = 0x1b;
15257         spec->autocfg.speaker_pins[0] = 0x14;
15258 }
15259
15260 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15261 {
15262         alc_automute_amp(codec);
15263         alc861vd_lenovo_mic_automute(codec);
15264 }
15265
15266 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15267                                         unsigned int res)
15268 {
15269         switch (res >> 26) {
15270         case ALC880_MIC_EVENT:
15271                 alc861vd_lenovo_mic_automute(codec);
15272                 break;
15273         default:
15274                 alc_automute_amp_unsol_event(codec, res);
15275                 break;
15276         }
15277 }
15278
15279 static struct hda_verb alc861vd_dallas_verbs[] = {
15280         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15281         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15282         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15283         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15284
15285         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15286         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15287         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15288         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15289         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15290         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15291         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15292         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15293
15294         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15295         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15296         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15297         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15298         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15299         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15300         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15301         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15302
15303         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15304         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15305         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15306         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15307         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15308         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15309         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15310         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15311
15312         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15313         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15314         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15315         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15316
15317         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15318         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15319         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15320
15321         { } /* end */
15322 };
15323
15324 /* toggle speaker-output according to the hp-jack state */
15325 static void alc861vd_dallas_setup(struct hda_codec *codec)
15326 {
15327         struct alc_spec *spec = codec->spec;
15328
15329         spec->autocfg.hp_pins[0] = 0x15;
15330         spec->autocfg.speaker_pins[0] = 0x14;
15331 }
15332
15333 #ifdef CONFIG_SND_HDA_POWER_SAVE
15334 #define alc861vd_loopbacks      alc880_loopbacks
15335 #endif
15336
15337 /* pcm configuration: identical with ALC880 */
15338 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15339 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15340 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15341 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15342
15343 /*
15344  * configuration and preset
15345  */
15346 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15347         [ALC660VD_3ST]          = "3stack-660",
15348         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15349         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15350         [ALC861VD_3ST]          = "3stack",
15351         [ALC861VD_3ST_DIG]      = "3stack-digout",
15352         [ALC861VD_6ST_DIG]      = "6stack-digout",
15353         [ALC861VD_LENOVO]       = "lenovo",
15354         [ALC861VD_DALLAS]       = "dallas",
15355         [ALC861VD_HP]           = "hp",
15356         [ALC861VD_AUTO]         = "auto",
15357 };
15358
15359 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15360         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15361         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15362         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15363         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15364         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15365         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15366         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15367         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15368         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15369         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15370         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15371         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15372         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15373         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15374         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15375         {}
15376 };
15377
15378 static struct alc_config_preset alc861vd_presets[] = {
15379         [ALC660VD_3ST] = {
15380                 .mixers = { alc861vd_3st_mixer },
15381                 .init_verbs = { alc861vd_volume_init_verbs,
15382                                  alc861vd_3stack_init_verbs },
15383                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15384                 .dac_nids = alc660vd_dac_nids,
15385                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15386                 .channel_mode = alc861vd_3stack_2ch_modes,
15387                 .input_mux = &alc861vd_capture_source,
15388         },
15389         [ALC660VD_3ST_DIG] = {
15390                 .mixers = { alc861vd_3st_mixer },
15391                 .init_verbs = { alc861vd_volume_init_verbs,
15392                                  alc861vd_3stack_init_verbs },
15393                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15394                 .dac_nids = alc660vd_dac_nids,
15395                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15396                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15397                 .channel_mode = alc861vd_3stack_2ch_modes,
15398                 .input_mux = &alc861vd_capture_source,
15399         },
15400         [ALC861VD_3ST] = {
15401                 .mixers = { alc861vd_3st_mixer },
15402                 .init_verbs = { alc861vd_volume_init_verbs,
15403                                  alc861vd_3stack_init_verbs },
15404                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15405                 .dac_nids = alc861vd_dac_nids,
15406                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15407                 .channel_mode = alc861vd_3stack_2ch_modes,
15408                 .input_mux = &alc861vd_capture_source,
15409         },
15410         [ALC861VD_3ST_DIG] = {
15411                 .mixers = { alc861vd_3st_mixer },
15412                 .init_verbs = { alc861vd_volume_init_verbs,
15413                                  alc861vd_3stack_init_verbs },
15414                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15415                 .dac_nids = alc861vd_dac_nids,
15416                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15417                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15418                 .channel_mode = alc861vd_3stack_2ch_modes,
15419                 .input_mux = &alc861vd_capture_source,
15420         },
15421         [ALC861VD_6ST_DIG] = {
15422                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15423                 .init_verbs = { alc861vd_volume_init_verbs,
15424                                 alc861vd_6stack_init_verbs },
15425                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15426                 .dac_nids = alc861vd_dac_nids,
15427                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15428                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15429                 .channel_mode = alc861vd_6stack_modes,
15430                 .input_mux = &alc861vd_capture_source,
15431         },
15432         [ALC861VD_LENOVO] = {
15433                 .mixers = { alc861vd_lenovo_mixer },
15434                 .init_verbs = { alc861vd_volume_init_verbs,
15435                                 alc861vd_3stack_init_verbs,
15436                                 alc861vd_eapd_verbs,
15437                                 alc861vd_lenovo_unsol_verbs },
15438                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15439                 .dac_nids = alc660vd_dac_nids,
15440                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15441                 .channel_mode = alc861vd_3stack_2ch_modes,
15442                 .input_mux = &alc861vd_capture_source,
15443                 .unsol_event = alc861vd_lenovo_unsol_event,
15444                 .setup = alc861vd_lenovo_setup,
15445                 .init_hook = alc861vd_lenovo_init_hook,
15446         },
15447         [ALC861VD_DALLAS] = {
15448                 .mixers = { alc861vd_dallas_mixer },
15449                 .init_verbs = { alc861vd_dallas_verbs },
15450                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15451                 .dac_nids = alc861vd_dac_nids,
15452                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15453                 .channel_mode = alc861vd_3stack_2ch_modes,
15454                 .input_mux = &alc861vd_dallas_capture_source,
15455                 .unsol_event = alc_automute_amp_unsol_event,
15456                 .setup = alc861vd_dallas_setup,
15457                 .init_hook = alc_automute_amp,
15458         },
15459         [ALC861VD_HP] = {
15460                 .mixers = { alc861vd_hp_mixer },
15461                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15462                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15463                 .dac_nids = alc861vd_dac_nids,
15464                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15465                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15466                 .channel_mode = alc861vd_3stack_2ch_modes,
15467                 .input_mux = &alc861vd_hp_capture_source,
15468                 .unsol_event = alc_automute_amp_unsol_event,
15469                 .setup = alc861vd_dallas_setup,
15470                 .init_hook = alc_automute_amp,
15471         },
15472         [ALC660VD_ASUS_V1S] = {
15473                 .mixers = { alc861vd_lenovo_mixer },
15474                 .init_verbs = { alc861vd_volume_init_verbs,
15475                                 alc861vd_3stack_init_verbs,
15476                                 alc861vd_eapd_verbs,
15477                                 alc861vd_lenovo_unsol_verbs },
15478                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15479                 .dac_nids = alc660vd_dac_nids,
15480                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15481                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15482                 .channel_mode = alc861vd_3stack_2ch_modes,
15483                 .input_mux = &alc861vd_capture_source,
15484                 .unsol_event = alc861vd_lenovo_unsol_event,
15485                 .setup = alc861vd_lenovo_setup,
15486                 .init_hook = alc861vd_lenovo_init_hook,
15487         },
15488 };
15489
15490 /*
15491  * BIOS auto configuration
15492  */
15493 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15494                                                 const struct auto_pin_cfg *cfg)
15495 {
15496         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x22, 0);
15497 }
15498
15499
15500 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15501                                 hda_nid_t nid, int pin_type, int dac_idx)
15502 {
15503         alc_set_pin_output(codec, nid, pin_type);
15504 }
15505
15506 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15507 {
15508         struct alc_spec *spec = codec->spec;
15509         int i;
15510
15511         for (i = 0; i <= HDA_SIDE; i++) {
15512                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15513                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15514                 if (nid)
15515                         alc861vd_auto_set_output_and_unmute(codec, nid,
15516                                                             pin_type, i);
15517         }
15518 }
15519
15520
15521 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15522 {
15523         struct alc_spec *spec = codec->spec;
15524         hda_nid_t pin;
15525
15526         pin = spec->autocfg.hp_pins[0];
15527         if (pin) /* connect to front and use dac 0 */
15528                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15529         pin = spec->autocfg.speaker_pins[0];
15530         if (pin)
15531                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15532 }
15533
15534 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15535
15536 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15537 {
15538         struct alc_spec *spec = codec->spec;
15539         int i;
15540
15541         for (i = 0; i < AUTO_PIN_LAST; i++) {
15542                 hda_nid_t nid = spec->autocfg.input_pins[i];
15543                 if (alc_is_input_pin(codec, nid)) {
15544                         alc_set_input_pin(codec, nid, i);
15545                         if (nid != ALC861VD_PIN_CD_NID &&
15546                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15547                                 snd_hda_codec_write(codec, nid, 0,
15548                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15549                                                 AMP_OUT_MUTE);
15550                 }
15551         }
15552 }
15553
15554 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15555
15556 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15557 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15558
15559 /* add playback controls from the parsed DAC table */
15560 /* Based on ALC880 version. But ALC861VD has separate,
15561  * different NIDs for mute/unmute switch and volume control */
15562 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15563                                              const struct auto_pin_cfg *cfg)
15564 {
15565         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15566         hda_nid_t nid_v, nid_s;
15567         int i, err;
15568
15569         for (i = 0; i < cfg->line_outs; i++) {
15570                 if (!spec->multiout.dac_nids[i])
15571                         continue;
15572                 nid_v = alc861vd_idx_to_mixer_vol(
15573                                 alc880_dac_to_idx(
15574                                         spec->multiout.dac_nids[i]));
15575                 nid_s = alc861vd_idx_to_mixer_switch(
15576                                 alc880_dac_to_idx(
15577                                         spec->multiout.dac_nids[i]));
15578
15579                 if (i == 2) {
15580                         /* Center/LFE */
15581                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15582                                               "Center",
15583                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15584                                                               HDA_OUTPUT));
15585                         if (err < 0)
15586                                 return err;
15587                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15588                                               "LFE",
15589                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15590                                                               HDA_OUTPUT));
15591                         if (err < 0)
15592                                 return err;
15593                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15594                                              "Center",
15595                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15596                                                               HDA_INPUT));
15597                         if (err < 0)
15598                                 return err;
15599                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15600                                              "LFE",
15601                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15602                                                               HDA_INPUT));
15603                         if (err < 0)
15604                                 return err;
15605                 } else {
15606                         const char *pfx;
15607                         if (cfg->line_outs == 1 &&
15608                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15609                                 if (!cfg->hp_pins)
15610                                         pfx = "Speaker";
15611                                 else
15612                                         pfx = "PCM";
15613                         } else
15614                                 pfx = chname[i];
15615                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15616                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15617                                                               HDA_OUTPUT));
15618                         if (err < 0)
15619                                 return err;
15620                         if (cfg->line_outs == 1 &&
15621                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15622                                 pfx = "Speaker";
15623                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15624                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15625                                                               HDA_INPUT));
15626                         if (err < 0)
15627                                 return err;
15628                 }
15629         }
15630         return 0;
15631 }
15632
15633 /* add playback controls for speaker and HP outputs */
15634 /* Based on ALC880 version. But ALC861VD has separate,
15635  * different NIDs for mute/unmute switch and volume control */
15636 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15637                                         hda_nid_t pin, const char *pfx)
15638 {
15639         hda_nid_t nid_v, nid_s;
15640         int err;
15641
15642         if (!pin)
15643                 return 0;
15644
15645         if (alc880_is_fixed_pin(pin)) {
15646                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15647                 /* specify the DAC as the extra output */
15648                 if (!spec->multiout.hp_nid)
15649                         spec->multiout.hp_nid = nid_v;
15650                 else
15651                         spec->multiout.extra_out_nid[0] = nid_v;
15652                 /* control HP volume/switch on the output mixer amp */
15653                 nid_v = alc861vd_idx_to_mixer_vol(
15654                                 alc880_fixed_pin_idx(pin));
15655                 nid_s = alc861vd_idx_to_mixer_switch(
15656                                 alc880_fixed_pin_idx(pin));
15657
15658                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15659                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15660                 if (err < 0)
15661                         return err;
15662                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15663                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15664                 if (err < 0)
15665                         return err;
15666         } else if (alc880_is_multi_pin(pin)) {
15667                 /* set manual connection */
15668                 /* we have only a switch on HP-out PIN */
15669                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
15670                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15671                 if (err < 0)
15672                         return err;
15673         }
15674         return 0;
15675 }
15676
15677 /* parse the BIOS configuration and set up the alc_spec
15678  * return 1 if successful, 0 if the proper config is not found,
15679  * or a negative error code
15680  * Based on ALC880 version - had to change it to override
15681  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15682 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15683 {
15684         struct alc_spec *spec = codec->spec;
15685         int err;
15686         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15687
15688         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15689                                            alc861vd_ignore);
15690         if (err < 0)
15691                 return err;
15692         if (!spec->autocfg.line_outs)
15693                 return 0; /* can't find valid BIOS pin config */
15694
15695         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15696         if (err < 0)
15697                 return err;
15698         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15699         if (err < 0)
15700                 return err;
15701         err = alc861vd_auto_create_extra_out(spec,
15702                                              spec->autocfg.speaker_pins[0],
15703                                              "Speaker");
15704         if (err < 0)
15705                 return err;
15706         err = alc861vd_auto_create_extra_out(spec,
15707                                              spec->autocfg.hp_pins[0],
15708                                              "Headphone");
15709         if (err < 0)
15710                 return err;
15711         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15712         if (err < 0)
15713                 return err;
15714
15715         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15716
15717         if (spec->autocfg.dig_outs)
15718                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15719
15720         if (spec->kctls.list)
15721                 add_mixer(spec, spec->kctls.list);
15722
15723         add_verb(spec, alc861vd_volume_init_verbs);
15724
15725         spec->num_mux_defs = 1;
15726         spec->input_mux = &spec->private_imux[0];
15727
15728         err = alc_auto_add_mic_boost(codec);
15729         if (err < 0)
15730                 return err;
15731
15732         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15733
15734         return 1;
15735 }
15736
15737 /* additional initialization for auto-configuration model */
15738 static void alc861vd_auto_init(struct hda_codec *codec)
15739 {
15740         struct alc_spec *spec = codec->spec;
15741         alc861vd_auto_init_multi_out(codec);
15742         alc861vd_auto_init_hp_out(codec);
15743         alc861vd_auto_init_analog_input(codec);
15744         alc861vd_auto_init_input_src(codec);
15745         if (spec->unsol_event)
15746                 alc_inithook(codec);
15747 }
15748
15749 enum {
15750         ALC660VD_FIX_ASUS_GPIO1
15751 };
15752
15753 /* reset GPIO1 */
15754 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15755         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15756         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15757         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15758         { }
15759 };
15760
15761 static const struct alc_fixup alc861vd_fixups[] = {
15762         [ALC660VD_FIX_ASUS_GPIO1] = {
15763                 .verbs = alc660vd_fix_asus_gpio1_verbs,
15764         },
15765 };
15766
15767 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15768         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15769         {}
15770 };
15771
15772 static int patch_alc861vd(struct hda_codec *codec)
15773 {
15774         struct alc_spec *spec;
15775         int err, board_config;
15776
15777         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15778         if (spec == NULL)
15779                 return -ENOMEM;
15780
15781         codec->spec = spec;
15782
15783         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15784                                                   alc861vd_models,
15785                                                   alc861vd_cfg_tbl);
15786
15787         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15788                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15789                        codec->chip_name);
15790                 board_config = ALC861VD_AUTO;
15791         }
15792
15793         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15794
15795         if (board_config == ALC861VD_AUTO) {
15796                 /* automatic parse from the BIOS config */
15797                 err = alc861vd_parse_auto_config(codec);
15798                 if (err < 0) {
15799                         alc_free(codec);
15800                         return err;
15801                 } else if (!err) {
15802                         printk(KERN_INFO
15803                                "hda_codec: Cannot set up configuration "
15804                                "from BIOS.  Using base mode...\n");
15805                         board_config = ALC861VD_3ST;
15806                 }
15807         }
15808
15809         err = snd_hda_attach_beep_device(codec, 0x23);
15810         if (err < 0) {
15811                 alc_free(codec);
15812                 return err;
15813         }
15814
15815         if (board_config != ALC861VD_AUTO)
15816                 setup_preset(codec, &alc861vd_presets[board_config]);
15817
15818         if (codec->vendor_id == 0x10ec0660) {
15819                 /* always turn on EAPD */
15820                 add_verb(spec, alc660vd_eapd_verbs);
15821         }
15822
15823         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15824         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15825
15826         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15827         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15828
15829         if (!spec->adc_nids) {
15830                 spec->adc_nids = alc861vd_adc_nids;
15831                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15832         }
15833         if (!spec->capsrc_nids)
15834                 spec->capsrc_nids = alc861vd_capsrc_nids;
15835
15836         set_capture_mixer(codec);
15837         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15838
15839         spec->vmaster_nid = 0x02;
15840
15841         codec->patch_ops = alc_patch_ops;
15842
15843         if (board_config == ALC861VD_AUTO)
15844                 spec->init_hook = alc861vd_auto_init;
15845 #ifdef CONFIG_SND_HDA_POWER_SAVE
15846         if (!spec->loopback.amplist)
15847                 spec->loopback.amplist = alc861vd_loopbacks;
15848 #endif
15849         codec->proc_widget_hook = print_realtek_coef;
15850
15851         return 0;
15852 }
15853
15854 /*
15855  * ALC662 support
15856  *
15857  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15858  * configuration.  Each pin widget can choose any input DACs and a mixer.
15859  * Each ADC is connected from a mixer of all inputs.  This makes possible
15860  * 6-channel independent captures.
15861  *
15862  * In addition, an independent DAC for the multi-playback (not used in this
15863  * driver yet).
15864  */
15865 #define ALC662_DIGOUT_NID       0x06
15866 #define ALC662_DIGIN_NID        0x0a
15867
15868 static hda_nid_t alc662_dac_nids[4] = {
15869         /* front, rear, clfe, rear_surr */
15870         0x02, 0x03, 0x04
15871 };
15872
15873 static hda_nid_t alc272_dac_nids[2] = {
15874         0x02, 0x03
15875 };
15876
15877 static hda_nid_t alc662_adc_nids[2] = {
15878         /* ADC1-2 */
15879         0x09, 0x08
15880 };
15881
15882 static hda_nid_t alc272_adc_nids[1] = {
15883         /* ADC1-2 */
15884         0x08,
15885 };
15886
15887 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15888 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15889
15890
15891 /* input MUX */
15892 /* FIXME: should be a matrix-type input source selection */
15893 static struct hda_input_mux alc662_capture_source = {
15894         .num_items = 4,
15895         .items = {
15896                 { "Mic", 0x0 },
15897                 { "Front Mic", 0x1 },
15898                 { "Line", 0x2 },
15899                 { "CD", 0x4 },
15900         },
15901 };
15902
15903 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15904         .num_items = 2,
15905         .items = {
15906                 { "Mic", 0x1 },
15907                 { "Line", 0x2 },
15908         },
15909 };
15910
15911 static struct hda_input_mux alc663_capture_source = {
15912         .num_items = 3,
15913         .items = {
15914                 { "Mic", 0x0 },
15915                 { "Front Mic", 0x1 },
15916                 { "Line", 0x2 },
15917         },
15918 };
15919
15920 #if 0 /* set to 1 for testing other input sources below */
15921 static struct hda_input_mux alc272_nc10_capture_source = {
15922         .num_items = 16,
15923         .items = {
15924                 { "Autoselect Mic", 0x0 },
15925                 { "Internal Mic", 0x1 },
15926                 { "In-0x02", 0x2 },
15927                 { "In-0x03", 0x3 },
15928                 { "In-0x04", 0x4 },
15929                 { "In-0x05", 0x5 },
15930                 { "In-0x06", 0x6 },
15931                 { "In-0x07", 0x7 },
15932                 { "In-0x08", 0x8 },
15933                 { "In-0x09", 0x9 },
15934                 { "In-0x0a", 0x0a },
15935                 { "In-0x0b", 0x0b },
15936                 { "In-0x0c", 0x0c },
15937                 { "In-0x0d", 0x0d },
15938                 { "In-0x0e", 0x0e },
15939                 { "In-0x0f", 0x0f },
15940         },
15941 };
15942 #endif
15943
15944 /*
15945  * 2ch mode
15946  */
15947 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15948         { 2, NULL }
15949 };
15950
15951 /*
15952  * 2ch mode
15953  */
15954 static struct hda_verb alc662_3ST_ch2_init[] = {
15955         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15956         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15957         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15958         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15959         { } /* end */
15960 };
15961
15962 /*
15963  * 6ch mode
15964  */
15965 static struct hda_verb alc662_3ST_ch6_init[] = {
15966         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15967         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15968         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15969         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15970         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15971         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15972         { } /* end */
15973 };
15974
15975 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15976         { 2, alc662_3ST_ch2_init },
15977         { 6, alc662_3ST_ch6_init },
15978 };
15979
15980 /*
15981  * 2ch mode
15982  */
15983 static struct hda_verb alc662_sixstack_ch6_init[] = {
15984         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15985         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15986         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15987         { } /* end */
15988 };
15989
15990 /*
15991  * 6ch mode
15992  */
15993 static struct hda_verb alc662_sixstack_ch8_init[] = {
15994         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15995         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15996         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15997         { } /* end */
15998 };
15999
16000 static struct hda_channel_mode alc662_5stack_modes[2] = {
16001         { 2, alc662_sixstack_ch6_init },
16002         { 6, alc662_sixstack_ch8_init },
16003 };
16004
16005 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16006  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16007  */
16008
16009 static struct snd_kcontrol_new alc662_base_mixer[] = {
16010         /* output mixer control */
16011         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16012         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16013         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16014         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16015         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16016         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16017         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16018         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16019         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16020
16021         /*Input mixer control */
16022         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16023         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16024         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16025         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16026         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16027         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16028         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16029         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16030         { } /* end */
16031 };
16032
16033 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16034         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16035         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16036         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16037         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16038         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16039         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16040         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16041         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16042         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16043         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16044         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16045         { } /* end */
16046 };
16047
16048 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16049         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16050         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16051         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16052         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16053         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16054         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16055         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16056         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16057         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16058         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16059         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16060         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16061         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16062         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16063         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16064         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16065         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16066         { } /* end */
16067 };
16068
16069 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16070         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16071         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16072         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16073         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16074         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16075         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16076         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16077         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16078         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16079         { } /* end */
16080 };
16081
16082 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16083         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16084         ALC262_HIPPO_MASTER_SWITCH,
16085
16086         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16087         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16088         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16089
16090         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16091         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16092         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16093         { } /* end */
16094 };
16095
16096 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16097         ALC262_HIPPO_MASTER_SWITCH,
16098         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16099         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16100         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16101         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16102         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16103         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16104         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16105         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16106         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16107         { } /* end */
16108 };
16109
16110 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16111         .ops = &snd_hda_bind_vol,
16112         .values = {
16113                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16114                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16115                 0
16116         },
16117 };
16118
16119 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16120         .ops = &snd_hda_bind_sw,
16121         .values = {
16122                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16123                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16124                 0
16125         },
16126 };
16127
16128 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16129         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16130         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16131         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16132         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16133         { } /* end */
16134 };
16135
16136 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16137         .ops = &snd_hda_bind_sw,
16138         .values = {
16139                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16140                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16141                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16142                 0
16143         },
16144 };
16145
16146 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16147         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16148         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16149         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16150         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16151         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16152         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16153
16154         { } /* end */
16155 };
16156
16157 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16158         .ops = &snd_hda_bind_sw,
16159         .values = {
16160                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16161                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16162                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16163                 0
16164         },
16165 };
16166
16167 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16168         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16169         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16170         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16171         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16172         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16173         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16174         { } /* end */
16175 };
16176
16177 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16178         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16179         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16180         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16181         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16182         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16183         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16184         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16185         { } /* end */
16186 };
16187
16188 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16189         .ops = &snd_hda_bind_vol,
16190         .values = {
16191                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16192                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16193                 0
16194         },
16195 };
16196
16197 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16198         .ops = &snd_hda_bind_sw,
16199         .values = {
16200                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16201                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16202                 0
16203         },
16204 };
16205
16206 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16207         HDA_BIND_VOL("Master Playback Volume",
16208                                 &alc663_asus_two_bind_master_vol),
16209         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16210         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16211         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16212         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16213         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16214         { } /* end */
16215 };
16216
16217 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16218         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16219         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16220         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16221         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16222         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16223         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16224         { } /* end */
16225 };
16226
16227 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16228         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16229         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16230         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16231         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16232         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16233
16234         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16235         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16236         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16237         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16238         { } /* end */
16239 };
16240
16241 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16242         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16243         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16244         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16245
16246         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16247         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16248         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16249         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16252         { } /* end */
16253 };
16254
16255 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16256         .ops = &snd_hda_bind_sw,
16257         .values = {
16258                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16259                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16260                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16261                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16262                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16263                 0
16264         },
16265 };
16266
16267 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16268         .ops = &snd_hda_bind_sw,
16269         .values = {
16270                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16271                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16272                 0
16273         },
16274 };
16275
16276 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16277         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16278         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16279         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16280         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16281         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16282         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16283         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16284         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16285         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16286         { } /* end */
16287 };
16288
16289 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16290         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16291         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16292         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16293         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16294         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16295         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16296         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16297         { } /* end */
16298 };
16299
16300
16301 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16302         {
16303                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16304                 .name = "Channel Mode",
16305                 .info = alc_ch_mode_info,
16306                 .get = alc_ch_mode_get,
16307                 .put = alc_ch_mode_put,
16308         },
16309         { } /* end */
16310 };
16311
16312 static struct hda_verb alc662_init_verbs[] = {
16313         /* ADC: mute amp left and right */
16314         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16315         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16316         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16317
16318         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16319         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16320         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16321         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16322         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16323
16324         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16325         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16326         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16327         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16328         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16329         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16330
16331         /* Front Pin: output 0 (0x0c) */
16332         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16333         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16334
16335         /* Rear Pin: output 1 (0x0d) */
16336         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16337         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16338
16339         /* CLFE Pin: output 2 (0x0e) */
16340         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16341         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16342
16343         /* Mic (rear) pin: input vref at 80% */
16344         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16345         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16346         /* Front Mic pin: input vref at 80% */
16347         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16348         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16349         /* Line In pin: input */
16350         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16351         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16352         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16353         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16354         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16355         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16356         /* CD pin widget for input */
16357         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16358
16359         /* FIXME: use matrix-type input source selection */
16360         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16361         /* Input mixer */
16362         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16363         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16364
16365         /* always trun on EAPD */
16366         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16367         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16368
16369         { }
16370 };
16371
16372 static struct hda_verb alc662_sue_init_verbs[] = {
16373         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16374         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16375         {}
16376 };
16377
16378 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16379         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16380         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16381         {}
16382 };
16383
16384 /* Set Unsolicited Event*/
16385 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16386         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16387         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16388         {}
16389 };
16390
16391 /*
16392  * generic initialization of ADC, input mixers and output mixers
16393  */
16394 static struct hda_verb alc662_auto_init_verbs[] = {
16395         /*
16396          * Unmute ADC and set the default input to mic-in
16397          */
16398         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16399         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16400
16401         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16402          * mixer widget
16403          * Note: PASD motherboards uses the Line In 2 as the input for front
16404          * panel mic (mic 2)
16405          */
16406         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16407         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16408         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16409         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16410         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16411         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16412
16413         /*
16414          * Set up output mixers (0x0c - 0x0f)
16415          */
16416         /* set vol=0 to output mixers */
16417         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16418         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16419         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16420
16421         /* set up input amps for analog loopback */
16422         /* Amp Indices: DAC = 0, mixer = 1 */
16423         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16424         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16425         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16426         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16427         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16428         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16429
16430
16431         /* FIXME: use matrix-type input source selection */
16432         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16433         /* Input mixer */
16434         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16435         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16436         { }
16437 };
16438
16439 /* additional verbs for ALC663 */
16440 static struct hda_verb alc663_auto_init_verbs[] = {
16441         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16442         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16443         { }
16444 };
16445
16446 static struct hda_verb alc663_m51va_init_verbs[] = {
16447         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16448         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16449         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16450         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16451         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16452         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16453         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16454         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16455         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16456         {}
16457 };
16458
16459 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16460         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16461         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16462         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16463         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16464         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16465         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16466         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16467         {}
16468 };
16469
16470 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16471         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16472         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16473         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16474         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16475         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16476         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16477         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16478         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16479         {}
16480 };
16481
16482 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16483         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16484         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16485         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16486         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16488         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16489         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16490         {}
16491 };
16492
16493 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16494         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16495         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16496         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16497         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16498         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16499         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16500         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16501         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16502         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16503         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16504         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16505         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16506         {}
16507 };
16508
16509 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16510         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16511         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16512         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16513         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16514         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16515         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16516         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16517         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16518         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16519         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16520         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16521         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16522         {}
16523 };
16524
16525 static struct hda_verb alc663_g71v_init_verbs[] = {
16526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16527         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16528         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16529
16530         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16531         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16532         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16533
16534         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16535         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16536         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16537         {}
16538 };
16539
16540 static struct hda_verb alc663_g50v_init_verbs[] = {
16541         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16542         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16543         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16544
16545         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16546         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16547         {}
16548 };
16549
16550 static struct hda_verb alc662_ecs_init_verbs[] = {
16551         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16552         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16553         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16554         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16555         {}
16556 };
16557
16558 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16559         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16560         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16561         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16562         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16563         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16564         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16565         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16566         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16567         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16568         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16569         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16570         {}
16571 };
16572
16573 static struct hda_verb alc272_dell_init_verbs[] = {
16574         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16575         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16576         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16577         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16578         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16579         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16580         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16581         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16582         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16583         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16584         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16585         {}
16586 };
16587
16588 static struct hda_verb alc663_mode7_init_verbs[] = {
16589         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16590         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16591         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16592         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16593         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16594         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16595         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
16596         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16597         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16598         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16599         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16601         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16602         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16603         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16604         {}
16605 };
16606
16607 static struct hda_verb alc663_mode8_init_verbs[] = {
16608         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16609         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16610         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16611         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16612         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16613         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16614         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16615         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16616         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16617         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16618         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16620         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16621         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16622         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16623         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16624         {}
16625 };
16626
16627 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16628         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16629         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16630         { } /* end */
16631 };
16632
16633 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16634         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16635         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16636         { } /* end */
16637 };
16638
16639 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16640 {
16641         unsigned int present;
16642         unsigned char bits;
16643
16644         present = snd_hda_jack_detect(codec, 0x14);
16645         bits = present ? HDA_AMP_MUTE : 0;
16646
16647         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16648                                  HDA_AMP_MUTE, bits);
16649 }
16650
16651 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16652 {
16653         unsigned int present;
16654         unsigned char bits;
16655
16656         present = snd_hda_jack_detect(codec, 0x1b);
16657         bits = present ? HDA_AMP_MUTE : 0;
16658
16659         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16660                                  HDA_AMP_MUTE, bits);
16661         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16662                                  HDA_AMP_MUTE, bits);
16663 }
16664
16665 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16666                                            unsigned int res)
16667 {
16668         if ((res >> 26) == ALC880_HP_EVENT)
16669                 alc662_lenovo_101e_all_automute(codec);
16670         if ((res >> 26) == ALC880_FRONT_EVENT)
16671                 alc662_lenovo_101e_ispeaker_automute(codec);
16672 }
16673
16674 /* unsolicited event for HP jack sensing */
16675 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16676                                      unsigned int res)
16677 {
16678         if ((res >> 26) == ALC880_MIC_EVENT)
16679                 alc_mic_automute(codec);
16680         else
16681                 alc262_hippo_unsol_event(codec, res);
16682 }
16683
16684 static void alc662_eeepc_setup(struct hda_codec *codec)
16685 {
16686         struct alc_spec *spec = codec->spec;
16687
16688         alc262_hippo1_setup(codec);
16689         spec->ext_mic.pin = 0x18;
16690         spec->ext_mic.mux_idx = 0;
16691         spec->int_mic.pin = 0x19;
16692         spec->int_mic.mux_idx = 1;
16693         spec->auto_mic = 1;
16694 }
16695
16696 static void alc662_eeepc_inithook(struct hda_codec *codec)
16697 {
16698         alc262_hippo_automute(codec);
16699         alc_mic_automute(codec);
16700 }
16701
16702 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16703 {
16704         struct alc_spec *spec = codec->spec;
16705
16706         spec->autocfg.hp_pins[0] = 0x14;
16707         spec->autocfg.speaker_pins[0] = 0x1b;
16708 }
16709
16710 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
16711
16712 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16713 {
16714         unsigned int present;
16715         unsigned char bits;
16716
16717         present = snd_hda_jack_detect(codec, 0x21);
16718         bits = present ? HDA_AMP_MUTE : 0;
16719         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16720                                 AMP_IN_MUTE(0), bits);
16721         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16722                                 AMP_IN_MUTE(0), bits);
16723 }
16724
16725 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16726 {
16727         unsigned int present;
16728         unsigned char bits;
16729
16730         present = snd_hda_jack_detect(codec, 0x21);
16731         bits = present ? HDA_AMP_MUTE : 0;
16732         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16733                                 AMP_IN_MUTE(0), bits);
16734         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16735                                 AMP_IN_MUTE(0), bits);
16736         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16737                                 AMP_IN_MUTE(0), bits);
16738         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16739                                 AMP_IN_MUTE(0), bits);
16740 }
16741
16742 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16743 {
16744         unsigned int present;
16745         unsigned char bits;
16746
16747         present = snd_hda_jack_detect(codec, 0x15);
16748         bits = present ? HDA_AMP_MUTE : 0;
16749         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16750                                 AMP_IN_MUTE(0), bits);
16751         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16752                                 AMP_IN_MUTE(0), bits);
16753         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16754                                 AMP_IN_MUTE(0), bits);
16755         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16756                                 AMP_IN_MUTE(0), bits);
16757 }
16758
16759 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16760 {
16761         unsigned int present;
16762         unsigned char bits;
16763
16764         present = snd_hda_jack_detect(codec, 0x1b);
16765         bits = present ? 0 : PIN_OUT;
16766         snd_hda_codec_write(codec, 0x14, 0,
16767                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16768 }
16769
16770 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16771 {
16772         unsigned int present1, present2;
16773
16774         present1 = snd_hda_jack_detect(codec, 0x21);
16775         present2 = snd_hda_jack_detect(codec, 0x15);
16776
16777         if (present1 || present2) {
16778                 snd_hda_codec_write_cache(codec, 0x14, 0,
16779                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16780         } else {
16781                 snd_hda_codec_write_cache(codec, 0x14, 0,
16782                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16783         }
16784 }
16785
16786 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16787 {
16788         unsigned int present1, present2;
16789
16790         present1 = snd_hda_jack_detect(codec, 0x1b);
16791         present2 = snd_hda_jack_detect(codec, 0x15);
16792
16793         if (present1 || present2) {
16794                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16795                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16796                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16797                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16798         } else {
16799                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16800                                 AMP_IN_MUTE(0), 0);
16801                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16802                                 AMP_IN_MUTE(0), 0);
16803         }
16804 }
16805
16806 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
16807 {
16808         unsigned int present1, present2;
16809
16810         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16811                         AC_VERB_GET_PIN_SENSE, 0)
16812                         & AC_PINSENSE_PRESENCE;
16813         present2 = snd_hda_codec_read(codec, 0x21, 0,
16814                         AC_VERB_GET_PIN_SENSE, 0)
16815                         & AC_PINSENSE_PRESENCE;
16816
16817         if (present1 || present2) {
16818                 snd_hda_codec_write_cache(codec, 0x14, 0,
16819                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16820                 snd_hda_codec_write_cache(codec, 0x17, 0,
16821                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16822         } else {
16823                 snd_hda_codec_write_cache(codec, 0x14, 0,
16824                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16825                 snd_hda_codec_write_cache(codec, 0x17, 0,
16826                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16827         }
16828 }
16829
16830 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
16831 {
16832         unsigned int present1, present2;
16833
16834         present1 = snd_hda_codec_read(codec, 0x21, 0,
16835                         AC_VERB_GET_PIN_SENSE, 0)
16836                         & AC_PINSENSE_PRESENCE;
16837         present2 = snd_hda_codec_read(codec, 0x15, 0,
16838                         AC_VERB_GET_PIN_SENSE, 0)
16839                         & AC_PINSENSE_PRESENCE;
16840
16841         if (present1 || present2) {
16842                 snd_hda_codec_write_cache(codec, 0x14, 0,
16843                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16844                 snd_hda_codec_write_cache(codec, 0x17, 0,
16845                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16846         } else {
16847                 snd_hda_codec_write_cache(codec, 0x14, 0,
16848                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16849                 snd_hda_codec_write_cache(codec, 0x17, 0,
16850                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16851         }
16852 }
16853
16854 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16855                                            unsigned int res)
16856 {
16857         switch (res >> 26) {
16858         case ALC880_HP_EVENT:
16859                 alc663_m51va_speaker_automute(codec);
16860                 break;
16861         case ALC880_MIC_EVENT:
16862                 alc_mic_automute(codec);
16863                 break;
16864         }
16865 }
16866
16867 static void alc663_m51va_setup(struct hda_codec *codec)
16868 {
16869         struct alc_spec *spec = codec->spec;
16870         spec->ext_mic.pin = 0x18;
16871         spec->ext_mic.mux_idx = 0;
16872         spec->int_mic.pin = 0x12;
16873         spec->int_mic.mux_idx = 9;
16874         spec->auto_mic = 1;
16875 }
16876
16877 static void alc663_m51va_inithook(struct hda_codec *codec)
16878 {
16879         alc663_m51va_speaker_automute(codec);
16880         alc_mic_automute(codec);
16881 }
16882
16883 /* ***************** Mode1 ******************************/
16884 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
16885
16886 static void alc663_mode1_setup(struct hda_codec *codec)
16887 {
16888         struct alc_spec *spec = codec->spec;
16889         spec->ext_mic.pin = 0x18;
16890         spec->ext_mic.mux_idx = 0;
16891         spec->int_mic.pin = 0x19;
16892         spec->int_mic.mux_idx = 1;
16893         spec->auto_mic = 1;
16894 }
16895
16896 #define alc663_mode1_inithook           alc663_m51va_inithook
16897
16898 /* ***************** Mode2 ******************************/
16899 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16900                                            unsigned int res)
16901 {
16902         switch (res >> 26) {
16903         case ALC880_HP_EVENT:
16904                 alc662_f5z_speaker_automute(codec);
16905                 break;
16906         case ALC880_MIC_EVENT:
16907                 alc_mic_automute(codec);
16908                 break;
16909         }
16910 }
16911
16912 #define alc662_mode2_setup      alc663_mode1_setup
16913
16914 static void alc662_mode2_inithook(struct hda_codec *codec)
16915 {
16916         alc662_f5z_speaker_automute(codec);
16917         alc_mic_automute(codec);
16918 }
16919 /* ***************** Mode3 ******************************/
16920 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16921                                            unsigned int res)
16922 {
16923         switch (res >> 26) {
16924         case ALC880_HP_EVENT:
16925                 alc663_two_hp_m1_speaker_automute(codec);
16926                 break;
16927         case ALC880_MIC_EVENT:
16928                 alc_mic_automute(codec);
16929                 break;
16930         }
16931 }
16932
16933 #define alc663_mode3_setup      alc663_mode1_setup
16934
16935 static void alc663_mode3_inithook(struct hda_codec *codec)
16936 {
16937         alc663_two_hp_m1_speaker_automute(codec);
16938         alc_mic_automute(codec);
16939 }
16940 /* ***************** Mode4 ******************************/
16941 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16942                                            unsigned int res)
16943 {
16944         switch (res >> 26) {
16945         case ALC880_HP_EVENT:
16946                 alc663_21jd_two_speaker_automute(codec);
16947                 break;
16948         case ALC880_MIC_EVENT:
16949                 alc_mic_automute(codec);
16950                 break;
16951         }
16952 }
16953
16954 #define alc663_mode4_setup      alc663_mode1_setup
16955
16956 static void alc663_mode4_inithook(struct hda_codec *codec)
16957 {
16958         alc663_21jd_two_speaker_automute(codec);
16959         alc_mic_automute(codec);
16960 }
16961 /* ***************** Mode5 ******************************/
16962 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16963                                            unsigned int res)
16964 {
16965         switch (res >> 26) {
16966         case ALC880_HP_EVENT:
16967                 alc663_15jd_two_speaker_automute(codec);
16968                 break;
16969         case ALC880_MIC_EVENT:
16970                 alc_mic_automute(codec);
16971                 break;
16972         }
16973 }
16974
16975 #define alc663_mode5_setup      alc663_mode1_setup
16976
16977 static void alc663_mode5_inithook(struct hda_codec *codec)
16978 {
16979         alc663_15jd_two_speaker_automute(codec);
16980         alc_mic_automute(codec);
16981 }
16982 /* ***************** Mode6 ******************************/
16983 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16984                                            unsigned int res)
16985 {
16986         switch (res >> 26) {
16987         case ALC880_HP_EVENT:
16988                 alc663_two_hp_m2_speaker_automute(codec);
16989                 break;
16990         case ALC880_MIC_EVENT:
16991                 alc_mic_automute(codec);
16992                 break;
16993         }
16994 }
16995
16996 #define alc663_mode6_setup      alc663_mode1_setup
16997
16998 static void alc663_mode6_inithook(struct hda_codec *codec)
16999 {
17000         alc663_two_hp_m2_speaker_automute(codec);
17001         alc_mic_automute(codec);
17002 }
17003
17004 /* ***************** Mode7 ******************************/
17005 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17006                                            unsigned int res)
17007 {
17008         switch (res >> 26) {
17009         case ALC880_HP_EVENT:
17010                 alc663_two_hp_m7_speaker_automute(codec);
17011                 break;
17012         case ALC880_MIC_EVENT:
17013                 alc_mic_automute(codec);
17014                 break;
17015         }
17016 }
17017
17018 #define alc663_mode7_setup      alc663_mode1_setup
17019
17020 static void alc663_mode7_inithook(struct hda_codec *codec)
17021 {
17022         alc663_two_hp_m7_speaker_automute(codec);
17023         alc_mic_automute(codec);
17024 }
17025
17026 /* ***************** Mode8 ******************************/
17027 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17028                                            unsigned int res)
17029 {
17030         switch (res >> 26) {
17031         case ALC880_HP_EVENT:
17032                 alc663_two_hp_m8_speaker_automute(codec);
17033                 break;
17034         case ALC880_MIC_EVENT:
17035                 alc_mic_automute(codec);
17036                 break;
17037         }
17038 }
17039
17040 #define alc663_mode8_setup      alc663_m51va_setup
17041
17042 static void alc663_mode8_inithook(struct hda_codec *codec)
17043 {
17044         alc663_two_hp_m8_speaker_automute(codec);
17045         alc_mic_automute(codec);
17046 }
17047
17048 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17049 {
17050         unsigned int present;
17051         unsigned char bits;
17052
17053         present = snd_hda_jack_detect(codec, 0x21);
17054         bits = present ? HDA_AMP_MUTE : 0;
17055         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17056                                  HDA_AMP_MUTE, bits);
17057         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17058                                  HDA_AMP_MUTE, bits);
17059 }
17060
17061 static void alc663_g71v_front_automute(struct hda_codec *codec)
17062 {
17063         unsigned int present;
17064         unsigned char bits;
17065
17066         present = snd_hda_jack_detect(codec, 0x15);
17067         bits = present ? HDA_AMP_MUTE : 0;
17068         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17069                                  HDA_AMP_MUTE, bits);
17070 }
17071
17072 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17073                                            unsigned int res)
17074 {
17075         switch (res >> 26) {
17076         case ALC880_HP_EVENT:
17077                 alc663_g71v_hp_automute(codec);
17078                 break;
17079         case ALC880_FRONT_EVENT:
17080                 alc663_g71v_front_automute(codec);
17081                 break;
17082         case ALC880_MIC_EVENT:
17083                 alc_mic_automute(codec);
17084                 break;
17085         }
17086 }
17087
17088 #define alc663_g71v_setup       alc663_m51va_setup
17089
17090 static void alc663_g71v_inithook(struct hda_codec *codec)
17091 {
17092         alc663_g71v_front_automute(codec);
17093         alc663_g71v_hp_automute(codec);
17094         alc_mic_automute(codec);
17095 }
17096
17097 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17098                                            unsigned int res)
17099 {
17100         switch (res >> 26) {
17101         case ALC880_HP_EVENT:
17102                 alc663_m51va_speaker_automute(codec);
17103                 break;
17104         case ALC880_MIC_EVENT:
17105                 alc_mic_automute(codec);
17106                 break;
17107         }
17108 }
17109
17110 #define alc663_g50v_setup       alc663_m51va_setup
17111
17112 static void alc663_g50v_inithook(struct hda_codec *codec)
17113 {
17114         alc663_m51va_speaker_automute(codec);
17115         alc_mic_automute(codec);
17116 }
17117
17118 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17119         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17120         ALC262_HIPPO_MASTER_SWITCH,
17121
17122         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17123         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17124         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17125
17126         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17127         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17128         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17129         { } /* end */
17130 };
17131
17132 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17133         /* Master Playback automatically created from Speaker and Headphone */
17134         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17135         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17136         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17137         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17138
17139         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17140         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17141         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17142
17143         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17144         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17145         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17146         { } /* end */
17147 };
17148
17149 #ifdef CONFIG_SND_HDA_POWER_SAVE
17150 #define alc662_loopbacks        alc880_loopbacks
17151 #endif
17152
17153
17154 /* pcm configuration: identical with ALC880 */
17155 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17156 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17157 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17158 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17159
17160 /*
17161  * configuration and preset
17162  */
17163 static const char *alc662_models[ALC662_MODEL_LAST] = {
17164         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17165         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17166         [ALC662_3ST_6ch]        = "3stack-6ch",
17167         [ALC662_5ST_DIG]        = "6stack-dig",
17168         [ALC662_LENOVO_101E]    = "lenovo-101e",
17169         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17170         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17171         [ALC662_ECS] = "ecs",
17172         [ALC663_ASUS_M51VA] = "m51va",
17173         [ALC663_ASUS_G71V] = "g71v",
17174         [ALC663_ASUS_H13] = "h13",
17175         [ALC663_ASUS_G50V] = "g50v",
17176         [ALC663_ASUS_MODE1] = "asus-mode1",
17177         [ALC662_ASUS_MODE2] = "asus-mode2",
17178         [ALC663_ASUS_MODE3] = "asus-mode3",
17179         [ALC663_ASUS_MODE4] = "asus-mode4",
17180         [ALC663_ASUS_MODE5] = "asus-mode5",
17181         [ALC663_ASUS_MODE6] = "asus-mode6",
17182         [ALC663_ASUS_MODE7] = "asus-mode7",
17183         [ALC663_ASUS_MODE8] = "asus-mode8",
17184         [ALC272_DELL]           = "dell",
17185         [ALC272_DELL_ZM1]       = "dell-zm1",
17186         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17187         [ALC662_AUTO]           = "auto",
17188 };
17189
17190 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17191         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17192         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17193         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17194         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17195         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17196         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17197         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17198         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17199         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17200         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17201         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17202         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17203         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17204         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17205         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17206         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17207         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17208         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17209         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17210         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17211         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17212         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17213         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17214         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17215         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17216         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17217         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17218         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17219         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17220         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17221         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17222         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17223         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17224         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17225         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17226         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17227         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17228         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17229         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17230         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17231         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17232         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17233         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17234         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17235         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17236         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17237         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17238         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17239         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17240         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17241         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17242         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17243         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17244         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17245         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17246         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17247         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17248         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17249         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17250         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17251         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17252         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17253                       ALC662_3ST_6ch_DIG),
17254         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
17255         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17256         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17257                       ALC662_3ST_6ch_DIG),
17258         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17259         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17260         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17261         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17262                                         ALC662_3ST_6ch_DIG),
17263         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17264                            ALC663_ASUS_H13),
17265         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17266         {}
17267 };
17268
17269 static struct alc_config_preset alc662_presets[] = {
17270         [ALC662_3ST_2ch_DIG] = {
17271                 .mixers = { alc662_3ST_2ch_mixer },
17272                 .init_verbs = { alc662_init_verbs },
17273                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17274                 .dac_nids = alc662_dac_nids,
17275                 .dig_out_nid = ALC662_DIGOUT_NID,
17276                 .dig_in_nid = ALC662_DIGIN_NID,
17277                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17278                 .channel_mode = alc662_3ST_2ch_modes,
17279                 .input_mux = &alc662_capture_source,
17280         },
17281         [ALC662_3ST_6ch_DIG] = {
17282                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17283                 .init_verbs = { alc662_init_verbs },
17284                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17285                 .dac_nids = alc662_dac_nids,
17286                 .dig_out_nid = ALC662_DIGOUT_NID,
17287                 .dig_in_nid = ALC662_DIGIN_NID,
17288                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17289                 .channel_mode = alc662_3ST_6ch_modes,
17290                 .need_dac_fix = 1,
17291                 .input_mux = &alc662_capture_source,
17292         },
17293         [ALC662_3ST_6ch] = {
17294                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17295                 .init_verbs = { alc662_init_verbs },
17296                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17297                 .dac_nids = alc662_dac_nids,
17298                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17299                 .channel_mode = alc662_3ST_6ch_modes,
17300                 .need_dac_fix = 1,
17301                 .input_mux = &alc662_capture_source,
17302         },
17303         [ALC662_5ST_DIG] = {
17304                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17305                 .init_verbs = { alc662_init_verbs },
17306                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17307                 .dac_nids = alc662_dac_nids,
17308                 .dig_out_nid = ALC662_DIGOUT_NID,
17309                 .dig_in_nid = ALC662_DIGIN_NID,
17310                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17311                 .channel_mode = alc662_5stack_modes,
17312                 .input_mux = &alc662_capture_source,
17313         },
17314         [ALC662_LENOVO_101E] = {
17315                 .mixers = { alc662_lenovo_101e_mixer },
17316                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17317                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17318                 .dac_nids = alc662_dac_nids,
17319                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17320                 .channel_mode = alc662_3ST_2ch_modes,
17321                 .input_mux = &alc662_lenovo_101e_capture_source,
17322                 .unsol_event = alc662_lenovo_101e_unsol_event,
17323                 .init_hook = alc662_lenovo_101e_all_automute,
17324         },
17325         [ALC662_ASUS_EEEPC_P701] = {
17326                 .mixers = { alc662_eeepc_p701_mixer },
17327                 .init_verbs = { alc662_init_verbs,
17328                                 alc662_eeepc_sue_init_verbs },
17329                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17330                 .dac_nids = alc662_dac_nids,
17331                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17332                 .channel_mode = alc662_3ST_2ch_modes,
17333                 .unsol_event = alc662_eeepc_unsol_event,
17334                 .setup = alc662_eeepc_setup,
17335                 .init_hook = alc662_eeepc_inithook,
17336         },
17337         [ALC662_ASUS_EEEPC_EP20] = {
17338                 .mixers = { alc662_eeepc_ep20_mixer,
17339                             alc662_chmode_mixer },
17340                 .init_verbs = { alc662_init_verbs,
17341                                 alc662_eeepc_ep20_sue_init_verbs },
17342                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17343                 .dac_nids = alc662_dac_nids,
17344                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17345                 .channel_mode = alc662_3ST_6ch_modes,
17346                 .input_mux = &alc662_lenovo_101e_capture_source,
17347                 .unsol_event = alc662_eeepc_unsol_event,
17348                 .setup = alc662_eeepc_ep20_setup,
17349                 .init_hook = alc662_eeepc_ep20_inithook,
17350         },
17351         [ALC662_ECS] = {
17352                 .mixers = { alc662_ecs_mixer },
17353                 .init_verbs = { alc662_init_verbs,
17354                                 alc662_ecs_init_verbs },
17355                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17356                 .dac_nids = alc662_dac_nids,
17357                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17358                 .channel_mode = alc662_3ST_2ch_modes,
17359                 .unsol_event = alc662_eeepc_unsol_event,
17360                 .setup = alc662_eeepc_setup,
17361                 .init_hook = alc662_eeepc_inithook,
17362         },
17363         [ALC663_ASUS_M51VA] = {
17364                 .mixers = { alc663_m51va_mixer },
17365                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17366                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17367                 .dac_nids = alc662_dac_nids,
17368                 .dig_out_nid = ALC662_DIGOUT_NID,
17369                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17370                 .channel_mode = alc662_3ST_2ch_modes,
17371                 .unsol_event = alc663_m51va_unsol_event,
17372                 .setup = alc663_m51va_setup,
17373                 .init_hook = alc663_m51va_inithook,
17374         },
17375         [ALC663_ASUS_G71V] = {
17376                 .mixers = { alc663_g71v_mixer },
17377                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17378                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17379                 .dac_nids = alc662_dac_nids,
17380                 .dig_out_nid = ALC662_DIGOUT_NID,
17381                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17382                 .channel_mode = alc662_3ST_2ch_modes,
17383                 .unsol_event = alc663_g71v_unsol_event,
17384                 .setup = alc663_g71v_setup,
17385                 .init_hook = alc663_g71v_inithook,
17386         },
17387         [ALC663_ASUS_H13] = {
17388                 .mixers = { alc663_m51va_mixer },
17389                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17390                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17391                 .dac_nids = alc662_dac_nids,
17392                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17393                 .channel_mode = alc662_3ST_2ch_modes,
17394                 .unsol_event = alc663_m51va_unsol_event,
17395                 .init_hook = alc663_m51va_inithook,
17396         },
17397         [ALC663_ASUS_G50V] = {
17398                 .mixers = { alc663_g50v_mixer },
17399                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17400                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17401                 .dac_nids = alc662_dac_nids,
17402                 .dig_out_nid = ALC662_DIGOUT_NID,
17403                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17404                 .channel_mode = alc662_3ST_6ch_modes,
17405                 .input_mux = &alc663_capture_source,
17406                 .unsol_event = alc663_g50v_unsol_event,
17407                 .setup = alc663_g50v_setup,
17408                 .init_hook = alc663_g50v_inithook,
17409         },
17410         [ALC663_ASUS_MODE1] = {
17411                 .mixers = { alc663_m51va_mixer },
17412                 .cap_mixer = alc662_auto_capture_mixer,
17413                 .init_verbs = { alc662_init_verbs,
17414                                 alc663_21jd_amic_init_verbs },
17415                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17416                 .hp_nid = 0x03,
17417                 .dac_nids = alc662_dac_nids,
17418                 .dig_out_nid = ALC662_DIGOUT_NID,
17419                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17420                 .channel_mode = alc662_3ST_2ch_modes,
17421                 .unsol_event = alc663_mode1_unsol_event,
17422                 .setup = alc663_mode1_setup,
17423                 .init_hook = alc663_mode1_inithook,
17424         },
17425         [ALC662_ASUS_MODE2] = {
17426                 .mixers = { alc662_1bjd_mixer },
17427                 .cap_mixer = alc662_auto_capture_mixer,
17428                 .init_verbs = { alc662_init_verbs,
17429                                 alc662_1bjd_amic_init_verbs },
17430                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17431                 .dac_nids = alc662_dac_nids,
17432                 .dig_out_nid = ALC662_DIGOUT_NID,
17433                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17434                 .channel_mode = alc662_3ST_2ch_modes,
17435                 .unsol_event = alc662_mode2_unsol_event,
17436                 .setup = alc662_mode2_setup,
17437                 .init_hook = alc662_mode2_inithook,
17438         },
17439         [ALC663_ASUS_MODE3] = {
17440                 .mixers = { alc663_two_hp_m1_mixer },
17441                 .cap_mixer = alc662_auto_capture_mixer,
17442                 .init_verbs = { alc662_init_verbs,
17443                                 alc663_two_hp_amic_m1_init_verbs },
17444                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17445                 .hp_nid = 0x03,
17446                 .dac_nids = alc662_dac_nids,
17447                 .dig_out_nid = ALC662_DIGOUT_NID,
17448                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17449                 .channel_mode = alc662_3ST_2ch_modes,
17450                 .unsol_event = alc663_mode3_unsol_event,
17451                 .setup = alc663_mode3_setup,
17452                 .init_hook = alc663_mode3_inithook,
17453         },
17454         [ALC663_ASUS_MODE4] = {
17455                 .mixers = { alc663_asus_21jd_clfe_mixer },
17456                 .cap_mixer = alc662_auto_capture_mixer,
17457                 .init_verbs = { alc662_init_verbs,
17458                                 alc663_21jd_amic_init_verbs},
17459                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17460                 .hp_nid = 0x03,
17461                 .dac_nids = alc662_dac_nids,
17462                 .dig_out_nid = ALC662_DIGOUT_NID,
17463                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17464                 .channel_mode = alc662_3ST_2ch_modes,
17465                 .unsol_event = alc663_mode4_unsol_event,
17466                 .setup = alc663_mode4_setup,
17467                 .init_hook = alc663_mode4_inithook,
17468         },
17469         [ALC663_ASUS_MODE5] = {
17470                 .mixers = { alc663_asus_15jd_clfe_mixer },
17471                 .cap_mixer = alc662_auto_capture_mixer,
17472                 .init_verbs = { alc662_init_verbs,
17473                                 alc663_15jd_amic_init_verbs },
17474                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17475                 .hp_nid = 0x03,
17476                 .dac_nids = alc662_dac_nids,
17477                 .dig_out_nid = ALC662_DIGOUT_NID,
17478                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17479                 .channel_mode = alc662_3ST_2ch_modes,
17480                 .unsol_event = alc663_mode5_unsol_event,
17481                 .setup = alc663_mode5_setup,
17482                 .init_hook = alc663_mode5_inithook,
17483         },
17484         [ALC663_ASUS_MODE6] = {
17485                 .mixers = { alc663_two_hp_m2_mixer },
17486                 .cap_mixer = alc662_auto_capture_mixer,
17487                 .init_verbs = { alc662_init_verbs,
17488                                 alc663_two_hp_amic_m2_init_verbs },
17489                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17490                 .hp_nid = 0x03,
17491                 .dac_nids = alc662_dac_nids,
17492                 .dig_out_nid = ALC662_DIGOUT_NID,
17493                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17494                 .channel_mode = alc662_3ST_2ch_modes,
17495                 .unsol_event = alc663_mode6_unsol_event,
17496                 .setup = alc663_mode6_setup,
17497                 .init_hook = alc663_mode6_inithook,
17498         },
17499         [ALC663_ASUS_MODE7] = {
17500                 .mixers = { alc663_mode7_mixer },
17501                 .cap_mixer = alc662_auto_capture_mixer,
17502                 .init_verbs = { alc662_init_verbs,
17503                                 alc663_mode7_init_verbs },
17504                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17505                 .hp_nid = 0x03,
17506                 .dac_nids = alc662_dac_nids,
17507                 .dig_out_nid = ALC662_DIGOUT_NID,
17508                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17509                 .channel_mode = alc662_3ST_2ch_modes,
17510                 .unsol_event = alc663_mode7_unsol_event,
17511                 .setup = alc663_mode7_setup,
17512                 .init_hook = alc663_mode7_inithook,
17513         },
17514         [ALC663_ASUS_MODE8] = {
17515                 .mixers = { alc663_mode8_mixer },
17516                 .cap_mixer = alc662_auto_capture_mixer,
17517                 .init_verbs = { alc662_init_verbs,
17518                                 alc663_mode8_init_verbs },
17519                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17520                 .hp_nid = 0x03,
17521                 .dac_nids = alc662_dac_nids,
17522                 .dig_out_nid = ALC662_DIGOUT_NID,
17523                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17524                 .channel_mode = alc662_3ST_2ch_modes,
17525                 .unsol_event = alc663_mode8_unsol_event,
17526                 .setup = alc663_mode8_setup,
17527                 .init_hook = alc663_mode8_inithook,
17528         },
17529         [ALC272_DELL] = {
17530                 .mixers = { alc663_m51va_mixer },
17531                 .cap_mixer = alc272_auto_capture_mixer,
17532                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17533                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17534                 .dac_nids = alc662_dac_nids,
17535                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17536                 .adc_nids = alc272_adc_nids,
17537                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17538                 .capsrc_nids = alc272_capsrc_nids,
17539                 .channel_mode = alc662_3ST_2ch_modes,
17540                 .unsol_event = alc663_m51va_unsol_event,
17541                 .setup = alc663_m51va_setup,
17542                 .init_hook = alc663_m51va_inithook,
17543         },
17544         [ALC272_DELL_ZM1] = {
17545                 .mixers = { alc663_m51va_mixer },
17546                 .cap_mixer = alc662_auto_capture_mixer,
17547                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17548                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17549                 .dac_nids = alc662_dac_nids,
17550                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17551                 .adc_nids = alc662_adc_nids,
17552                 .num_adc_nids = 1,
17553                 .capsrc_nids = alc662_capsrc_nids,
17554                 .channel_mode = alc662_3ST_2ch_modes,
17555                 .unsol_event = alc663_m51va_unsol_event,
17556                 .setup = alc663_m51va_setup,
17557                 .init_hook = alc663_m51va_inithook,
17558         },
17559         [ALC272_SAMSUNG_NC10] = {
17560                 .mixers = { alc272_nc10_mixer },
17561                 .init_verbs = { alc662_init_verbs,
17562                                 alc663_21jd_amic_init_verbs },
17563                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17564                 .dac_nids = alc272_dac_nids,
17565                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17566                 .channel_mode = alc662_3ST_2ch_modes,
17567                 /*.input_mux = &alc272_nc10_capture_source,*/
17568                 .unsol_event = alc663_mode4_unsol_event,
17569                 .setup = alc663_mode4_setup,
17570                 .init_hook = alc663_mode4_inithook,
17571         },
17572 };
17573
17574
17575 /*
17576  * BIOS auto configuration
17577  */
17578
17579 /* convert from MIX nid to DAC */
17580 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17581 {
17582         if (nid == 0x0f)
17583                 return 0x02;
17584         else if (nid >= 0x0c && nid <= 0x0e)
17585                 return nid - 0x0c + 0x02;
17586         else
17587                 return 0;
17588 }
17589
17590 /* get MIX nid connected to the given pin targeted to DAC */
17591 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17592                                    hda_nid_t dac)
17593 {
17594         hda_nid_t mix[4];
17595         int i, num;
17596
17597         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17598         for (i = 0; i < num; i++) {
17599                 if (alc662_mix_to_dac(mix[i]) == dac)
17600                         return mix[i];
17601         }
17602         return 0;
17603 }
17604
17605 /* look for an empty DAC slot */
17606 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17607 {
17608         struct alc_spec *spec = codec->spec;
17609         hda_nid_t srcs[5];
17610         int i, j, num;
17611
17612         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17613         if (num < 0)
17614                 return 0;
17615         for (i = 0; i < num; i++) {
17616                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17617                 if (!nid)
17618                         continue;
17619                 for (j = 0; j < spec->multiout.num_dacs; j++)
17620                         if (spec->multiout.dac_nids[j] == nid)
17621                                 break;
17622                 if (j >= spec->multiout.num_dacs)
17623                         return nid;
17624         }
17625         return 0;
17626 }
17627
17628 /* fill in the dac_nids table from the parsed pin configuration */
17629 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17630                                      const struct auto_pin_cfg *cfg)
17631 {
17632         struct alc_spec *spec = codec->spec;
17633         int i;
17634         hda_nid_t dac;
17635
17636         spec->multiout.dac_nids = spec->private_dac_nids;
17637         for (i = 0; i < cfg->line_outs; i++) {
17638                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17639                 if (!dac)
17640                         continue;
17641                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17642         }
17643         return 0;
17644 }
17645
17646 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17647                               hda_nid_t nid, unsigned int chs)
17648 {
17649         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17650                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17651 }
17652
17653 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17654                              hda_nid_t nid, unsigned int chs)
17655 {
17656         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17657                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17658 }
17659
17660 #define alc662_add_stereo_vol(spec, pfx, nid) \
17661         alc662_add_vol_ctl(spec, pfx, nid, 3)
17662 #define alc662_add_stereo_sw(spec, pfx, nid) \
17663         alc662_add_sw_ctl(spec, pfx, nid, 3)
17664
17665 /* add playback controls from the parsed DAC table */
17666 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17667                                              const struct auto_pin_cfg *cfg)
17668 {
17669         struct alc_spec *spec = codec->spec;
17670         static const char *chname[4] = {
17671                 "Front", "Surround", NULL /*CLFE*/, "Side"
17672         };
17673         hda_nid_t nid, mix;
17674         int i, err;
17675
17676         for (i = 0; i < cfg->line_outs; i++) {
17677                 nid = spec->multiout.dac_nids[i];
17678                 if (!nid)
17679                         continue;
17680                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17681                 if (!mix)
17682                         continue;
17683                 if (i == 2) {
17684                         /* Center/LFE */
17685                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17686                         if (err < 0)
17687                                 return err;
17688                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17689                         if (err < 0)
17690                                 return err;
17691                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17692                         if (err < 0)
17693                                 return err;
17694                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17695                         if (err < 0)
17696                                 return err;
17697                 } else {
17698                         const char *pfx;
17699                         if (cfg->line_outs == 1 &&
17700                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17701                                 if (cfg->hp_outs)
17702                                         pfx = "Speaker";
17703                                 else
17704                                         pfx = "PCM";
17705                         } else
17706                                 pfx = chname[i];
17707                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17708                         if (err < 0)
17709                                 return err;
17710                         if (cfg->line_outs == 1 &&
17711                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17712                                 pfx = "Speaker";
17713                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17714                         if (err < 0)
17715                                 return err;
17716                 }
17717         }
17718         return 0;
17719 }
17720
17721 /* add playback controls for speaker and HP outputs */
17722 /* return DAC nid if any new DAC is assigned */
17723 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17724                                         const char *pfx)
17725 {
17726         struct alc_spec *spec = codec->spec;
17727         hda_nid_t nid, mix;
17728         int err;
17729
17730         if (!pin)
17731                 return 0;
17732         nid = alc662_look_for_dac(codec, pin);
17733         if (!nid) {
17734                 /* the corresponding DAC is already occupied */
17735                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17736                         return 0; /* no way */
17737                 /* create a switch only */
17738                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17739                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17740         }
17741
17742         mix = alc662_dac_to_mix(codec, pin, nid);
17743         if (!mix)
17744                 return 0;
17745         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17746         if (err < 0)
17747                 return err;
17748         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17749         if (err < 0)
17750                 return err;
17751         return nid;
17752 }
17753
17754 /* create playback/capture controls for input pins */
17755 #define alc662_auto_create_input_ctls \
17756         alc882_auto_create_input_ctls
17757
17758 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17759                                               hda_nid_t nid, int pin_type,
17760                                               hda_nid_t dac)
17761 {
17762         int i, num;
17763         hda_nid_t srcs[4];
17764
17765         alc_set_pin_output(codec, nid, pin_type);
17766         /* need the manual connection? */
17767         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17768         if (num <= 1)
17769                 return;
17770         for (i = 0; i < num; i++) {
17771                 if (alc662_mix_to_dac(srcs[i]) != dac)
17772                         continue;
17773                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17774                 return;
17775         }
17776 }
17777
17778 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17779 {
17780         struct alc_spec *spec = codec->spec;
17781         int pin_type = get_pin_type(spec->autocfg.line_out_type);
17782         int i;
17783
17784         for (i = 0; i <= HDA_SIDE; i++) {
17785                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17786                 if (nid)
17787                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17788                                         spec->multiout.dac_nids[i]);
17789         }
17790 }
17791
17792 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17793 {
17794         struct alc_spec *spec = codec->spec;
17795         hda_nid_t pin;
17796
17797         pin = spec->autocfg.hp_pins[0];
17798         if (pin)
17799                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17800                                                   spec->multiout.hp_nid);
17801         pin = spec->autocfg.speaker_pins[0];
17802         if (pin)
17803                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17804                                         spec->multiout.extra_out_nid[0]);
17805 }
17806
17807 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17808
17809 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17810 {
17811         struct alc_spec *spec = codec->spec;
17812         int i;
17813
17814         for (i = 0; i < AUTO_PIN_LAST; i++) {
17815                 hda_nid_t nid = spec->autocfg.input_pins[i];
17816                 if (alc_is_input_pin(codec, nid)) {
17817                         alc_set_input_pin(codec, nid, i);
17818                         if (nid != ALC662_PIN_CD_NID &&
17819                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17820                                 snd_hda_codec_write(codec, nid, 0,
17821                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17822                                                     AMP_OUT_MUTE);
17823                 }
17824         }
17825 }
17826
17827 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17828
17829 static int alc662_parse_auto_config(struct hda_codec *codec)
17830 {
17831         struct alc_spec *spec = codec->spec;
17832         int err;
17833         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17834
17835         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17836                                            alc662_ignore);
17837         if (err < 0)
17838                 return err;
17839         if (!spec->autocfg.line_outs)
17840                 return 0; /* can't find valid BIOS pin config */
17841
17842         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17843         if (err < 0)
17844                 return err;
17845         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17846         if (err < 0)
17847                 return err;
17848         err = alc662_auto_create_extra_out(codec,
17849                                            spec->autocfg.speaker_pins[0],
17850                                            "Speaker");
17851         if (err < 0)
17852                 return err;
17853         if (err)
17854                 spec->multiout.extra_out_nid[0] = err;
17855         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17856                                            "Headphone");
17857         if (err < 0)
17858                 return err;
17859         if (err)
17860                 spec->multiout.hp_nid = err;
17861         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17862         if (err < 0)
17863                 return err;
17864
17865         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17866
17867         if (spec->autocfg.dig_outs)
17868                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17869
17870         if (spec->kctls.list)
17871                 add_mixer(spec, spec->kctls.list);
17872
17873         spec->num_mux_defs = 1;
17874         spec->input_mux = &spec->private_imux[0];
17875
17876         add_verb(spec, alc662_auto_init_verbs);
17877         if (codec->vendor_id == 0x10ec0663)
17878                 add_verb(spec, alc663_auto_init_verbs);
17879
17880         err = alc_auto_add_mic_boost(codec);
17881         if (err < 0)
17882                 return err;
17883
17884         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17885
17886         return 1;
17887 }
17888
17889 /* additional initialization for auto-configuration model */
17890 static void alc662_auto_init(struct hda_codec *codec)
17891 {
17892         struct alc_spec *spec = codec->spec;
17893         alc662_auto_init_multi_out(codec);
17894         alc662_auto_init_hp_out(codec);
17895         alc662_auto_init_analog_input(codec);
17896         alc662_auto_init_input_src(codec);
17897         if (spec->unsol_event)
17898                 alc_inithook(codec);
17899 }
17900
17901 static int patch_alc662(struct hda_codec *codec)
17902 {
17903         struct alc_spec *spec;
17904         int err, board_config;
17905
17906         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17907         if (!spec)
17908                 return -ENOMEM;
17909
17910         codec->spec = spec;
17911
17912         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17913
17914         if (alc_read_coef_idx(codec, 0)==0x8020){
17915                 kfree(codec->chip_name);
17916                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
17917                 if (!codec->chip_name) {
17918                         alc_free(codec);
17919                         return -ENOMEM;
17920                 }
17921         }
17922
17923         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17924                                                   alc662_models,
17925                                                   alc662_cfg_tbl);
17926         if (board_config < 0) {
17927                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17928                        codec->chip_name);
17929                 board_config = ALC662_AUTO;
17930         }
17931
17932         if (board_config == ALC662_AUTO) {
17933                 /* automatic parse from the BIOS config */
17934                 err = alc662_parse_auto_config(codec);
17935                 if (err < 0) {
17936                         alc_free(codec);
17937                         return err;
17938                 } else if (!err) {
17939                         printk(KERN_INFO
17940                                "hda_codec: Cannot set up configuration "
17941                                "from BIOS.  Using base mode...\n");
17942                         board_config = ALC662_3ST_2ch_DIG;
17943                 }
17944         }
17945
17946         err = snd_hda_attach_beep_device(codec, 0x1);
17947         if (err < 0) {
17948                 alc_free(codec);
17949                 return err;
17950         }
17951
17952         if (board_config != ALC662_AUTO)
17953                 setup_preset(codec, &alc662_presets[board_config]);
17954
17955         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17956         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17957
17958         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17959         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17960
17961         if (!spec->adc_nids) {
17962                 spec->adc_nids = alc662_adc_nids;
17963                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17964         }
17965         if (!spec->capsrc_nids)
17966                 spec->capsrc_nids = alc662_capsrc_nids;
17967
17968         if (!spec->cap_mixer)
17969                 set_capture_mixer(codec);
17970         if (codec->vendor_id == 0x10ec0662)
17971                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17972         else
17973                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17974
17975         spec->vmaster_nid = 0x02;
17976
17977         codec->patch_ops = alc_patch_ops;
17978         if (board_config == ALC662_AUTO)
17979                 spec->init_hook = alc662_auto_init;
17980 #ifdef CONFIG_SND_HDA_POWER_SAVE
17981         if (!spec->loopback.amplist)
17982                 spec->loopback.amplist = alc662_loopbacks;
17983 #endif
17984         codec->proc_widget_hook = print_realtek_coef;
17985
17986         return 0;
17987 }
17988
17989 static int patch_alc888(struct hda_codec *codec)
17990 {
17991         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
17992                 kfree(codec->chip_name);
17993                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
17994                 if (!codec->chip_name) {
17995                         alc_free(codec);
17996                         return -ENOMEM;
17997                 }
17998                 return patch_alc662(codec);
17999         }
18000         return patch_alc882(codec);
18001 }
18002
18003 /*
18004  * patch entries
18005  */
18006 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18007         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18008         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18009         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18010         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18011         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18012         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18013         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18014         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18015         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18016           .patch = patch_alc861 },
18017         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18018         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18019         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18020         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18021           .patch = patch_alc882 },
18022         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18023           .patch = patch_alc662 },
18024         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18025         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18026         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18027         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18028         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18029           .patch = patch_alc882 },
18030         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18031           .patch = patch_alc882 },
18032         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18033         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18034         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18035           .patch = patch_alc882 },
18036         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18037         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18038         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18039         {} /* terminator */
18040 };
18041
18042 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18043
18044 MODULE_LICENSE("GPL");
18045 MODULE_DESCRIPTION("Realtek HD-audio codec");
18046
18047 static struct hda_codec_preset_list realtek_list = {
18048         .preset = snd_hda_preset_realtek,
18049         .owner = THIS_MODULE,
18050 };
18051
18052 static int __init patch_realtek_init(void)
18053 {
18054         return snd_hda_add_codec_preset(&realtek_list);
18055 }
18056
18057 static void __exit patch_realtek_exit(void)
18058 {
18059         snd_hda_delete_codec_preset(&realtek_list);
18060 }
18061
18062 module_init(patch_realtek_init)
18063 module_exit(patch_realtek_exit)