sound/pci/hda/patch_realtek.c

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC883_3ST_2ch_DIG,
 212         ALC883_3ST_6ch_DIG,
 213         ALC883_3ST_6ch,
 214         ALC883_6ST_DIG,
 215         ALC883_TARGA_DIG,
 216         ALC883_TARGA_2ch_DIG,
 217         ALC883_TARGA_8ch_DIG,
 218         ALC883_ACER,
 219         ALC883_ACER_ASPIRE,
 220         ALC888_ACER_ASPIRE_4930G,
 221         ALC888_ACER_ASPIRE_6530G,
 222         ALC888_ACER_ASPIRE_8930G,
 223         ALC883_MEDION,
 224         ALC883_MEDION_MD2,
 225         ALC883_LAPTOP_EAPD,
 226         ALC883_LENOVO_101E_2ch,
 227         ALC883_LENOVO_NB0763,
 228         ALC888_LENOVO_MS7195_DIG,
 229         ALC888_LENOVO_SKY,
 230         ALC883_HAIER_W66,
 231         ALC888_3ST_HP,
 232         ALC888_6ST_DELL,
 233         ALC883_MITAC,
 234         ALC883_CLEVO_M720,
 235         ALC883_FUJITSU_PI2515,
 236         ALC888_FUJITSU_XA3530,
 237         ALC883_3ST_6ch_INTEL,
 238         ALC889A_INTEL,
 239         ALC889_INTEL,
 240         ALC888_ASUS_M90V,
 241         ALC888_ASUS_EEE1601,
 242         ALC889A_MB31,
 243         ALC1200_ASUS_P5Q,
 244         ALC883_SONY_VAIO_TT,
 245         ALC882_AUTO,
 246         ALC882_MODEL_LAST,
 247 };
 248
 249 /* for GPIO Poll */
 250 #define GPIO_MASK       0x03
 251
 252 /* extra amp-initialization sequence types */
 253 enum {
 254         ALC_INIT_NONE,
 255         ALC_INIT_DEFAULT,
 256         ALC_INIT_GPIO1,
 257         ALC_INIT_GPIO2,
 258         ALC_INIT_GPIO3,
 259 };
 260
 261 struct alc_mic_route {
 262         hda_nid_t pin;
 263         unsigned char mux_idx;
 264         unsigned char amix_idx;
 265 };
 266
 267 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 268
 269 struct alc_spec {
 270         /* codec parameterization */
 271         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 272         unsigned int num_mixers;
 273         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 274         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 275
 276         const struct hda_verb *init_verbs[5];   /* initialization verbs
 277                                                  * don't forget NULL
 278                                                  * termination!
 279                                                  */
 280         unsigned int num_init_verbs;
 281
 282         char stream_name_analog[32];    /* analog PCM stream */
 283         struct hda_pcm_stream *stream_analog_playback;
 284         struct hda_pcm_stream *stream_analog_capture;
 285         struct hda_pcm_stream *stream_analog_alt_playback;
 286         struct hda_pcm_stream *stream_analog_alt_capture;
 287
 288         char stream_name_digital[32];   /* digital PCM stream */
 289         struct hda_pcm_stream *stream_digital_playback;
 290         struct hda_pcm_stream *stream_digital_capture;
 291
 292         /* playback */
 293         struct hda_multi_out multiout;  /* playback set-up
 294                                          * max_channels, dacs must be set
 295                                          * dig_out_nid and hp_nid are optional
 296                                          */
 297         hda_nid_t alt_dac_nid;
 298         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 299         int dig_out_type;
 300
 301         /* capture */
 302         unsigned int num_adc_nids;
 303         hda_nid_t *adc_nids;
 304         hda_nid_t *capsrc_nids;
 305         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 306
 307         /* capture source */
 308         unsigned int num_mux_defs;
 309         const struct hda_input_mux *input_mux;
 310         unsigned int cur_mux[3];
 311         struct alc_mic_route ext_mic;
 312         struct alc_mic_route int_mic;
 313
 314         /* channel model */
 315         const struct hda_channel_mode *channel_mode;
 316         int num_channel_mode;
 317         int need_dac_fix;
 318         int const_channel_count;
 319         int ext_channel_count;
 320
 321         /* PCM information */
 322         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 323
 324         /* dynamic controls, init_verbs and input_mux */
 325         struct auto_pin_cfg autocfg;
 326         struct snd_array kctls;
 327         struct hda_input_mux private_imux[3];
 328         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 329         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 330         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 331
 332         /* hooks */
 333         void (*init_hook)(struct hda_codec *codec);
 334         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 335
 336         /* for pin sensing */
 337         unsigned int sense_updated: 1;
 338         unsigned int jack_present: 1;
 339         unsigned int master_sw: 1;
 340         unsigned int auto_mic:1;
 341
 342         /* other flags */
 343         unsigned int no_analog :1; /* digital I/O only */
 344         int init_amp;
 345
 346         /* for virtual master */
 347         hda_nid_t vmaster_nid;
 348 #ifdef CONFIG_SND_HDA_POWER_SAVE
 349         struct hda_loopback_check loopback;
 350 #endif
 351
 352         /* for PLL fix */
 353         hda_nid_t pll_nid;
 354         unsigned int pll_coef_idx, pll_coef_bit;
 355 };
 356
 357 /*
 358  * configuration template - to be copied to the spec instance
 359  */
 360 struct alc_config_preset {
 361         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 362                                              * with spec
 363                                              */
 364         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 365         const struct hda_verb *init_verbs[5];
 366         unsigned int num_dacs;
 367         hda_nid_t *dac_nids;
 368         hda_nid_t dig_out_nid;          /* optional */
 369         hda_nid_t hp_nid;               /* optional */
 370         hda_nid_t *slave_dig_outs;
 371         unsigned int num_adc_nids;
 372         hda_nid_t *adc_nids;
 373         hda_nid_t *capsrc_nids;
 374         hda_nid_t dig_in_nid;
 375         unsigned int num_channel_mode;
 376         const struct hda_channel_mode *channel_mode;
 377         int need_dac_fix;
 378         int const_channel_count;
 379         unsigned int num_mux_defs;
 380         const struct hda_input_mux *input_mux;
 381         void (*unsol_event)(struct hda_codec *, unsigned int);
 382         void (*init_hook)(struct hda_codec *);
 383 #ifdef CONFIG_SND_HDA_POWER_SAVE
 384         struct hda_amp_list *loopbacks;
 385 #endif
 386 };
 387
 388
 389 /*
 390  * input MUX handling
 391  */
 392 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 393                              struct snd_ctl_elem_info *uinfo)
 394 {
 395         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 396         struct alc_spec *spec = codec->spec;
 397         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 398         if (mux_idx >= spec->num_mux_defs)
 399                 mux_idx = 0;
 400         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 401 }
 402
 403 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 404                             struct snd_ctl_elem_value *ucontrol)
 405 {
 406         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 407         struct alc_spec *spec = codec->spec;
 408         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 409
 410         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 411         return 0;
 412 }
 413
 414 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 415                             struct snd_ctl_elem_value *ucontrol)
 416 {
 417         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 418         struct alc_spec *spec = codec->spec;
 419         const struct hda_input_mux *imux;
 420         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 421         unsigned int mux_idx;
 422         hda_nid_t nid = spec->capsrc_nids ?
 423                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 424         unsigned int type;
 425
 426         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 427         imux = &spec->input_mux[mux_idx];
 428
 429         type = get_wcaps_type(get_wcaps(codec, nid));
 430         if (type == AC_WID_AUD_MIX) {
 431                 /* Matrix-mixer style (e.g. ALC882) */
 432                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 433                 unsigned int i, idx;
 434
 435                 idx = ucontrol->value.enumerated.item[0];
 436                 if (idx >= imux->num_items)
 437                         idx = imux->num_items - 1;
 438                 if (*cur_val == idx)
 439                         return 0;
 440                 for (i = 0; i < imux->num_items; i++) {
 441                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 442                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 443                                                  imux->items[i].index,
 444                                                  HDA_AMP_MUTE, v);
 445                 }
 446                 *cur_val = idx;
 447                 return 1;
 448         } else {
 449                 /* MUX style (e.g. ALC880) */
 450                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 451                                              &spec->cur_mux[adc_idx]);
 452         }
 453 }
 454
 455 /*
 456  * channel mode setting
 457  */
 458 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 459                             struct snd_ctl_elem_info *uinfo)
 460 {
 461         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 462         struct alc_spec *spec = codec->spec;
 463         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 464                                     spec->num_channel_mode);
 465 }
 466
 467 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 468                            struct snd_ctl_elem_value *ucontrol)
 469 {
 470         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 471         struct alc_spec *spec = codec->spec;
 472         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 473                                    spec->num_channel_mode,
 474                                    spec->ext_channel_count);
 475 }
 476
 477 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 478                            struct snd_ctl_elem_value *ucontrol)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 483                                       spec->num_channel_mode,
 484                                       &spec->ext_channel_count);
 485         if (err >= 0 && !spec->const_channel_count) {
 486                 spec->multiout.max_channels = spec->ext_channel_count;
 487                 if (spec->need_dac_fix)
 488                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 489         }
 490         return err;
 491 }
 492
 493 /*
 494  * Control the mode of pin widget settings via the mixer.  "pc" is used
 495  * instead of "%" to avoid consequences of accidently treating the % as
 496  * being part of a format specifier.  Maximum allowed length of a value is
 497  * 63 characters plus NULL terminator.
 498  *
 499  * Note: some retasking pin complexes seem to ignore requests for input
 500  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 501  * are requested.  Therefore order this list so that this behaviour will not
 502  * cause problems when mixer clients move through the enum sequentially.
 503  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 504  * March 2006.
 505  */
 506 static char *alc_pin_mode_names[] = {
 507         "Mic 50pc bias", "Mic 80pc bias",
 508         "Line in", "Line out", "Headphone out",
 509 };
 510 static unsigned char alc_pin_mode_values[] = {
 511         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 512 };
 513 /* The control can present all 5 options, or it can limit the options based
 514  * in the pin being assumed to be exclusively an input or an output pin.  In
 515  * addition, "input" pins may or may not process the mic bias option
 516  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 517  * accept requests for bias as of chip versions up to March 2006) and/or
 518  * wiring in the computer.
 519  */
 520 #define ALC_PIN_DIR_IN              0x00
 521 #define ALC_PIN_DIR_OUT             0x01
 522 #define ALC_PIN_DIR_INOUT           0x02
 523 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 524 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 525
 526 /* Info about the pin modes supported by the different pin direction modes.
 527  * For each direction the minimum and maximum values are given.
 528  */
 529 static signed char alc_pin_mode_dir_info[5][2] = {
 530         { 0, 2 },    /* ALC_PIN_DIR_IN */
 531         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 532         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 533         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 534         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 535 };
 536 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 537 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 538 #define alc_pin_mode_n_items(_dir) \
 539         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 540
 541 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 542                              struct snd_ctl_elem_info *uinfo)
 543 {
 544         unsigned int item_num = uinfo->value.enumerated.item;
 545         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 546
 547         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 548         uinfo->count = 1;
 549         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 550
 551         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 552                 item_num = alc_pin_mode_min(dir);
 553         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 554         return 0;
 555 }
 556
 557 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 558                             struct snd_ctl_elem_value *ucontrol)
 559 {
 560         unsigned int i;
 561         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 562         hda_nid_t nid = kcontrol->private_value & 0xffff;
 563         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 564         long *valp = ucontrol->value.integer.value;
 565         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 566                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 567                                                  0x00);
 568
 569         /* Find enumerated value for current pinctl setting */
 570         i = alc_pin_mode_min(dir);
 571         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 572                 i++;
 573         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 574         return 0;
 575 }
 576
 577 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 578                             struct snd_ctl_elem_value *ucontrol)
 579 {
 580         signed int change;
 581         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 582         hda_nid_t nid = kcontrol->private_value & 0xffff;
 583         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 584         long val = *ucontrol->value.integer.value;
 585         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 586                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 587                                                  0x00);
 588
 589         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 590                 val = alc_pin_mode_min(dir);
 591
 592         change = pinctl != alc_pin_mode_values[val];
 593         if (change) {
 594                 /* Set pin mode to that requested */
 595                 snd_hda_codec_write_cache(codec, nid, 0,
 596                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 597                                           alc_pin_mode_values[val]);
 598
 599                 /* Also enable the retasking pin's input/output as required
 600                  * for the requested pin mode.  Enum values of 2 or less are
 601                  * input modes.
 602                  *
 603                  * Dynamically switching the input/output buffers probably
 604                  * reduces noise slightly (particularly on input) so we'll
 605                  * do it.  However, having both input and output buffers
 606                  * enabled simultaneously doesn't seem to be problematic if
 607                  * this turns out to be necessary in the future.
 608                  */
 609                 if (val <= 2) {
 610                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 611                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 612                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 613                                                  HDA_AMP_MUTE, 0);
 614                 } else {
 615                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 616                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 617                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 618                                                  HDA_AMP_MUTE, 0);
 619                 }
 620         }
 621         return change;
 622 }
 623
 624 #define ALC_PIN_MODE(xname, nid, dir) \
 625         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 626           .info = alc_pin_mode_info, \
 627           .get = alc_pin_mode_get, \
 628           .put = alc_pin_mode_put, \
 629           .private_value = nid | (dir<<16) }
 630
 631 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 632  * together using a mask with more than one bit set.  This control is
 633  * currently used only by the ALC260 test model.  At this stage they are not
 634  * needed for any "production" models.
 635  */
 636 #ifdef CONFIG_SND_DEBUG
 637 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 638
 639 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 640                              struct snd_ctl_elem_value *ucontrol)
 641 {
 642         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 643         hda_nid_t nid = kcontrol->private_value & 0xffff;
 644         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 645         long *valp = ucontrol->value.integer.value;
 646         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 647                                               AC_VERB_GET_GPIO_DATA, 0x00);
 648
 649         *valp = (val & mask) != 0;
 650         return 0;
 651 }
 652 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 653                              struct snd_ctl_elem_value *ucontrol)
 654 {
 655         signed int change;
 656         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 657         hda_nid_t nid = kcontrol->private_value & 0xffff;
 658         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 659         long val = *ucontrol->value.integer.value;
 660         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 661                                                     AC_VERB_GET_GPIO_DATA,
 662                                                     0x00);
 663
 664         /* Set/unset the masked GPIO bit(s) as needed */
 665         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 666         if (val == 0)
 667                 gpio_data &= ~mask;
 668         else
 669                 gpio_data |= mask;
 670         snd_hda_codec_write_cache(codec, nid, 0,
 671                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 672
 673         return change;
 674 }
 675 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 676         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 677           .info = alc_gpio_data_info, \
 678           .get = alc_gpio_data_get, \
 679           .put = alc_gpio_data_put, \
 680           .private_value = nid | (mask<<16) }
 681 #endif   /* CONFIG_SND_DEBUG */
 682
 683 /* A switch control to allow the enabling of the digital IO pins on the
 684  * ALC260.  This is incredibly simplistic; the intention of this control is
 685  * to provide something in the test model allowing digital outputs to be
 686  * identified if present.  If models are found which can utilise these
 687  * outputs a more complete mixer control can be devised for those models if
 688  * necessary.
 689  */
 690 #ifdef CONFIG_SND_DEBUG
 691 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 692
 693 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 694                               struct snd_ctl_elem_value *ucontrol)
 695 {
 696         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 697         hda_nid_t nid = kcontrol->private_value & 0xffff;
 698         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 699         long *valp = ucontrol->value.integer.value;
 700         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 701                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 702
 703         *valp = (val & mask) != 0;
 704         return 0;
 705 }
 706 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 707                               struct snd_ctl_elem_value *ucontrol)
 708 {
 709         signed int change;
 710         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 711         hda_nid_t nid = kcontrol->private_value & 0xffff;
 712         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 713         long val = *ucontrol->value.integer.value;
 714         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 715                                                     AC_VERB_GET_DIGI_CONVERT_1,
 716                                                     0x00);
 717
 718         /* Set/unset the masked control bit(s) as needed */
 719         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 720         if (val==0)
 721                 ctrl_data &= ~mask;
 722         else
 723                 ctrl_data |= mask;
 724         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 725                                   ctrl_data);
 726
 727         return change;
 728 }
 729 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 730         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 731           .info = alc_spdif_ctrl_info, \
 732           .get = alc_spdif_ctrl_get, \
 733           .put = alc_spdif_ctrl_put, \
 734           .private_value = nid | (mask<<16) }
 735 #endif   /* CONFIG_SND_DEBUG */
 736
 737 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 738  * Again, this is only used in the ALC26x test models to help identify when
 739  * the EAPD line must be asserted for features to work.
 740  */
 741 #ifdef CONFIG_SND_DEBUG
 742 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 743
 744 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 745                               struct snd_ctl_elem_value *ucontrol)
 746 {
 747         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 748         hda_nid_t nid = kcontrol->private_value & 0xffff;
 749         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 750         long *valp = ucontrol->value.integer.value;
 751         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 752                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 753
 754         *valp = (val & mask) != 0;
 755         return 0;
 756 }
 757
 758 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 759                               struct snd_ctl_elem_value *ucontrol)
 760 {
 761         int change;
 762         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 763         hda_nid_t nid = kcontrol->private_value & 0xffff;
 764         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 765         long val = *ucontrol->value.integer.value;
 766         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 767                                                     AC_VERB_GET_EAPD_BTLENABLE,
 768                                                     0x00);
 769
 770         /* Set/unset the masked control bit(s) as needed */
 771         change = (!val ? 0 : mask) != (ctrl_data & mask);
 772         if (!val)
 773                 ctrl_data &= ~mask;
 774         else
 775                 ctrl_data |= mask;
 776         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 777                                   ctrl_data);
 778
 779         return change;
 780 }
 781
 782 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 783         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 784           .info = alc_eapd_ctrl_info, \
 785           .get = alc_eapd_ctrl_get, \
 786           .put = alc_eapd_ctrl_put, \
 787           .private_value = nid | (mask<<16) }
 788 #endif   /* CONFIG_SND_DEBUG */
 789
 790 /*
 791  * set up the input pin config (depending on the given auto-pin type)
 792  */
 793 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 794                               int auto_pin_type)
 795 {
 796         unsigned int val = PIN_IN;
 797
 798         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 799                 unsigned int pincap;
 800                 pincap = snd_hda_query_pin_caps(codec, nid);
 801                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 802                 if (pincap & AC_PINCAP_VREF_80)
 803                         val = PIN_VREF80;
 804                 else if (pincap & AC_PINCAP_VREF_50)
 805                         val = PIN_VREF50;
 806                 else if (pincap & AC_PINCAP_VREF_100)
 807                         val = PIN_VREF100;
 808                 else if (pincap & AC_PINCAP_VREF_GRD)
 809                         val = PIN_VREFGRD;
 810         }
 811         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 812 }
 813
 814 /*
 815  */
 816 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 817 {
 818         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 819                 return;
 820         spec->mixers[spec->num_mixers++] = mix;
 821 }
 822
 823 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 824 {
 825         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 826                 return;
 827         spec->init_verbs[spec->num_init_verbs++] = verb;
 828 }
 829
 830 #ifdef CONFIG_PROC_FS
 831 /*
 832  * hook for proc
 833  */
 834 static void print_realtek_coef(struct snd_info_buffer *buffer,
 835                                struct hda_codec *codec, hda_nid_t nid)
 836 {
 837         int coeff;
 838
 839         if (nid != 0x20)
 840                 return;
 841         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 842         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 843         coeff = snd_hda_codec_read(codec, nid, 0,
 844                                    AC_VERB_GET_COEF_INDEX, 0);
 845         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 846 }
 847 #else
 848 #define print_realtek_coef      NULL
 849 #endif
 850
 851 /*
 852  * set up from the preset table
 853  */
 854 static void setup_preset(struct alc_spec *spec,
 855                          const struct alc_config_preset *preset)
 856 {
 857         int i;
 858
 859         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 860                 add_mixer(spec, preset->mixers[i]);
 861         spec->cap_mixer = preset->cap_mixer;
 862         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 863              i++)
 864                 add_verb(spec, preset->init_verbs[i]);
 865
 866         spec->channel_mode = preset->channel_mode;
 867         spec->num_channel_mode = preset->num_channel_mode;
 868         spec->need_dac_fix = preset->need_dac_fix;
 869         spec->const_channel_count = preset->const_channel_count;
 870
 871         if (preset->const_channel_count)
 872                 spec->multiout.max_channels = preset->const_channel_count;
 873         else
 874                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 875         spec->ext_channel_count = spec->channel_mode[0].channels;
 876
 877         spec->multiout.num_dacs = preset->num_dacs;
 878         spec->multiout.dac_nids = preset->dac_nids;
 879         spec->multiout.dig_out_nid = preset->dig_out_nid;
 880         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 881         spec->multiout.hp_nid = preset->hp_nid;
 882
 883         spec->num_mux_defs = preset->num_mux_defs;
 884         if (!spec->num_mux_defs)
 885                 spec->num_mux_defs = 1;
 886         spec->input_mux = preset->input_mux;
 887
 888         spec->num_adc_nids = preset->num_adc_nids;
 889         spec->adc_nids = preset->adc_nids;
 890         spec->capsrc_nids = preset->capsrc_nids;
 891         spec->dig_in_nid = preset->dig_in_nid;
 892
 893         spec->unsol_event = preset->unsol_event;
 894         spec->init_hook = preset->init_hook;
 895 #ifdef CONFIG_SND_HDA_POWER_SAVE
 896         spec->loopback.amplist = preset->loopbacks;
 897 #endif
 898 }
 899
 900 /* Enable GPIO mask and set output */
 901 static struct hda_verb alc_gpio1_init_verbs[] = {
 902         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 903         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 904         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 905         { }
 906 };
 907
 908 static struct hda_verb alc_gpio2_init_verbs[] = {
 909         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 910         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 911         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 912         { }
 913 };
 914
 915 static struct hda_verb alc_gpio3_init_verbs[] = {
 916         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 917         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 918         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 919         { }
 920 };
 921
 922 /*
 923  * Fix hardware PLL issue
 924  * On some codecs, the analog PLL gating control must be off while
 925  * the default value is 1.
 926  */
 927 static void alc_fix_pll(struct hda_codec *codec)
 928 {
 929         struct alc_spec *spec = codec->spec;
 930         unsigned int val;
 931
 932         if (!spec->pll_nid)
 933                 return;
 934         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 935                             spec->pll_coef_idx);
 936         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 937                                  AC_VERB_GET_PROC_COEF, 0);
 938         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 939                             spec->pll_coef_idx);
 940         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 941                             val & ~(1 << spec->pll_coef_bit));
 942 }
 943
 944 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 945                              unsigned int coef_idx, unsigned int coef_bit)
 946 {
 947         struct alc_spec *spec = codec->spec;
 948         spec->pll_nid = nid;
 949         spec->pll_coef_idx = coef_idx;
 950         spec->pll_coef_bit = coef_bit;
 951         alc_fix_pll(codec);
 952 }
 953
 954 static void alc_automute_pin(struct hda_codec *codec)
 955 {
 956         struct alc_spec *spec = codec->spec;
 957         unsigned int present, pincap;
 958         unsigned int nid = spec->autocfg.hp_pins[0];
 959         int i;
 960
 961         pincap = snd_hda_query_pin_caps(codec, nid);
 962         if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
 963                 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 964         present = snd_hda_codec_read(codec, nid, 0,
 965                                      AC_VERB_GET_PIN_SENSE, 0);
 966         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 967         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 968                 nid = spec->autocfg.speaker_pins[i];
 969                 if (!nid)
 970                         break;
 971                 snd_hda_codec_write(codec, nid, 0,
 972                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 973                                     spec->jack_present ? 0 : PIN_OUT);
 974         }
 975 }
 976
 977 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 978                                 hda_nid_t nid)
 979 {
 980         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 981         int i, nums;
 982
 983         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 984         for (i = 0; i < nums; i++)
 985                 if (conn[i] == nid)
 986                         return i;
 987         return -1;
 988 }
 989
 990 static int set_mic_mux_idx(struct hda_codec *codec, hda_nid_t cap,
 991                            struct alc_mic_route *mic)
 992 {
 993         int idx = get_connection_index(codec, cap, mic->pin);
 994         if (idx < 0)
 995                 return 1; /* invalid */
 996         mic->mux_idx = idx;
 997         return 0;
 998 }
 999
1000 static void alc_mic_automute(struct hda_codec *codec)
1001 {
1002         struct alc_spec *spec = codec->spec;
1003         struct alc_mic_route *dead, *alive;
1004         unsigned int present, type;
1005         hda_nid_t cap_nid;
1006
1007         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1008                 return;
1009         if (snd_BUG_ON(!spec->adc_nids))
1010                 return;
1011
1012         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1013
1014         present = snd_hda_codec_read(codec, spec->ext_mic.pin, 0,
1015                                      AC_VERB_GET_PIN_SENSE, 0);
1016         present &= AC_PINSENSE_PRESENCE;
1017         if (present) {
1018                 alive = &spec->ext_mic;
1019                 dead = &spec->int_mic;
1020         } else {
1021                 alive = &spec->int_mic;
1022                 dead = &spec->ext_mic;
1023         }
1024
1025         if (alive->mux_idx == MUX_IDX_UNDEF &&
1026             set_mic_mux_idx(codec, cap_nid, alive))
1027                 return;
1028         if (dead->mux_idx == MUX_IDX_UNDEF &&
1029             set_mic_mux_idx(codec, cap_nid, dead))
1030                 return;
1031
1032         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1033         if (type == AC_WID_AUD_MIX) {
1034                 /* Matrix-mixer style (e.g. ALC882) */
1035                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1036                                          alive->mux_idx,
1037                                          HDA_AMP_MUTE, 0);
1038                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1039                                          dead->mux_idx,
1040                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1041         } else {
1042                 /* MUX style (e.g. ALC880) */
1043                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1044                                           AC_VERB_SET_CONNECT_SEL,
1045                                           alive->mux_idx);
1046         }
1047
1048         /* FIXME: analog mixer */
1049 }
1050
1051 /* unsolicited event for HP jack sensing */
1052 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1053 {
1054         if (codec->vendor_id == 0x10ec0880)
1055                 res >>= 28;
1056         else
1057                 res >>= 26;
1058         switch (res) {
1059         case ALC880_HP_EVENT:
1060                 alc_automute_pin(codec);
1061                 break;
1062         case ALC880_MIC_EVENT:
1063                 alc_mic_automute(codec);
1064                 break;
1065         }
1066 }
1067
1068 static void alc_inithook(struct hda_codec *codec)
1069 {
1070         alc_automute_pin(codec);
1071         alc_mic_automute(codec);
1072 }
1073
1074 /* additional initialization for ALC888 variants */
1075 static void alc888_coef_init(struct hda_codec *codec)
1076 {
1077         unsigned int tmp;
1078
1079         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1080         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1081         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1082         if ((tmp & 0xf0) == 0x20)
1083                 /* alc888S-VC */
1084                 snd_hda_codec_read(codec, 0x20, 0,
1085                                    AC_VERB_SET_PROC_COEF, 0x830);
1086          else
1087                  /* alc888-VB */
1088                  snd_hda_codec_read(codec, 0x20, 0,
1089                                     AC_VERB_SET_PROC_COEF, 0x3030);
1090 }
1091
1092 static void alc889_coef_init(struct hda_codec *codec)
1093 {
1094         unsigned int tmp;
1095
1096         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1097         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1098         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1099         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1100 }
1101
1102 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1103 {
1104         unsigned int tmp;
1105
1106         switch (type) {
1107         case ALC_INIT_GPIO1:
1108                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1109                 break;
1110         case ALC_INIT_GPIO2:
1111                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1112                 break;
1113         case ALC_INIT_GPIO3:
1114                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1115                 break;
1116         case ALC_INIT_DEFAULT:
1117                 switch (codec->vendor_id) {
1118                 case 0x10ec0260:
1119                         snd_hda_codec_write(codec, 0x0f, 0,
1120                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1121                         snd_hda_codec_write(codec, 0x10, 0,
1122                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1123                         break;
1124                 case 0x10ec0262:
1125                 case 0x10ec0267:
1126                 case 0x10ec0268:
1127                 case 0x10ec0269:
1128                 case 0x10ec0272:
1129                 case 0x10ec0660:
1130                 case 0x10ec0662:
1131                 case 0x10ec0663:
1132                 case 0x10ec0862:
1133                 case 0x10ec0889:
1134                         snd_hda_codec_write(codec, 0x14, 0,
1135                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1136                         snd_hda_codec_write(codec, 0x15, 0,
1137                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1138                         break;
1139                 }
1140                 switch (codec->vendor_id) {
1141                 case 0x10ec0260:
1142                         snd_hda_codec_write(codec, 0x1a, 0,
1143                                             AC_VERB_SET_COEF_INDEX, 7);
1144                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1145                                                  AC_VERB_GET_PROC_COEF, 0);
1146                         snd_hda_codec_write(codec, 0x1a, 0,
1147                                             AC_VERB_SET_COEF_INDEX, 7);
1148                         snd_hda_codec_write(codec, 0x1a, 0,
1149                                             AC_VERB_SET_PROC_COEF,
1150                                             tmp | 0x2010);
1151                         break;
1152                 case 0x10ec0262:
1153                 case 0x10ec0880:
1154                 case 0x10ec0882:
1155                 case 0x10ec0883:
1156                 case 0x10ec0885:
1157                 case 0x10ec0887:
1158                 case 0x10ec0889:
1159                         alc889_coef_init(codec);
1160                         break;
1161                 case 0x10ec0888:
1162                         alc888_coef_init(codec);
1163                         break;
1164                 case 0x10ec0267:
1165                 case 0x10ec0268:
1166                         snd_hda_codec_write(codec, 0x20, 0,
1167                                             AC_VERB_SET_COEF_INDEX, 7);
1168                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1169                                                  AC_VERB_GET_PROC_COEF, 0);
1170                         snd_hda_codec_write(codec, 0x20, 0,
1171                                             AC_VERB_SET_COEF_INDEX, 7);
1172                         snd_hda_codec_write(codec, 0x20, 0,
1173                                             AC_VERB_SET_PROC_COEF,
1174                                             tmp | 0x3000);
1175                         break;
1176                 }
1177                 break;
1178         }
1179 }
1180
1181 static void alc_init_auto_hp(struct hda_codec *codec)
1182 {
1183         struct alc_spec *spec = codec->spec;
1184
1185         if (!spec->autocfg.hp_pins[0])
1186                 return;
1187
1188         if (!spec->autocfg.speaker_pins[0]) {
1189                 if (spec->autocfg.line_out_pins[0] &&
1190                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1191                         spec->autocfg.speaker_pins[0] =
1192                                 spec->autocfg.line_out_pins[0];
1193                 else
1194                         return;
1195         }
1196
1197         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1198                     spec->autocfg.hp_pins[0]);
1199         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1200                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1201                                   AC_USRSP_EN | ALC880_HP_EVENT);
1202         spec->unsol_event = alc_sku_unsol_event;
1203 }
1204
1205 static void alc_init_auto_mic(struct hda_codec *codec)
1206 {
1207         struct alc_spec *spec = codec->spec;
1208         struct auto_pin_cfg *cfg = &spec->autocfg;
1209         hda_nid_t fixed, ext;
1210         int i;
1211
1212         /* there must be only two mic inputs exclusively */
1213         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1214                 if (cfg->input_pins[i])
1215                         return;
1216
1217         fixed = ext = 0;
1218         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1219                 hda_nid_t nid = cfg->input_pins[i];
1220                 unsigned int defcfg;
1221                 if (!nid)
1222                         return;
1223                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1224                 switch (get_defcfg_connect(defcfg)) {
1225                 case AC_JACK_PORT_FIXED:
1226                         if (fixed)
1227                                 return; /* already occupied */
1228                         fixed = nid;
1229                         break;
1230                 case AC_JACK_PORT_COMPLEX:
1231                         if (ext)
1232                                 return; /* already occupied */
1233                         ext = nid;
1234                         break;
1235                 default:
1236                         return; /* invalid entry */
1237                 }
1238         }
1239         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1240                 return; /* no unsol support */
1241         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1242                     ext, fixed);
1243         spec->ext_mic.pin = ext;
1244         spec->int_mic.pin = fixed;
1245         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1246         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1247         spec->auto_mic = 1;
1248         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1249                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1250                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1251         spec->unsol_event = alc_sku_unsol_event;
1252 }
1253
1254 /* check subsystem ID and set up device-specific initialization;
1255  * return 1 if initialized, 0 if invalid SSID
1256  */
1257 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1258  *      31 ~ 16 :       Manufacture ID
1259  *      15 ~ 8  :       SKU ID
1260  *      7  ~ 0  :       Assembly ID
1261  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1262  */
1263 static int alc_subsystem_id(struct hda_codec *codec,
1264                             hda_nid_t porta, hda_nid_t porte,
1265                             hda_nid_t portd)
1266 {
1267         unsigned int ass, tmp, i;
1268         unsigned nid;
1269         struct alc_spec *spec = codec->spec;
1270
1271         ass = codec->subsystem_id & 0xffff;
1272         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1273                 goto do_sku;
1274
1275         /* invalid SSID, check the special NID pin defcfg instead */
1276         /*
1277          * 31~30        : port connectivity
1278          * 29~21        : reserve
1279          * 20           : PCBEEP input
1280          * 19~16        : Check sum (15:1)
1281          * 15~1         : Custom
1282          * 0            : override
1283         */
1284         nid = 0x1d;
1285         if (codec->vendor_id == 0x10ec0260)
1286                 nid = 0x17;
1287         ass = snd_hda_codec_get_pincfg(codec, nid);
1288         snd_printd("realtek: No valid SSID, "
1289                    "checking pincfg 0x%08x for NID 0x%x\n",
1290                    ass, nid);
1291         if (!(ass & 1) && !(ass & 0x100000))
1292                 return 0;
1293         if ((ass >> 30) != 1)   /* no physical connection */
1294                 return 0;
1295
1296         /* check sum */
1297         tmp = 0;
1298         for (i = 1; i < 16; i++) {
1299                 if ((ass >> i) & 1)
1300                         tmp++;
1301         }
1302         if (((ass >> 16) & 0xf) != tmp)
1303                 return 0;
1304 do_sku:
1305         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1306                    ass & 0xffff, codec->vendor_id);
1307         /*
1308          * 0 : override
1309          * 1 :  Swap Jack
1310          * 2 : 0 --> Desktop, 1 --> Laptop
1311          * 3~5 : External Amplifier control
1312          * 7~6 : Reserved
1313         */
1314         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1315         switch (tmp) {
1316         case 1:
1317                 spec->init_amp = ALC_INIT_GPIO1;
1318                 break;
1319         case 3:
1320                 spec->init_amp = ALC_INIT_GPIO2;
1321                 break;
1322         case 7:
1323                 spec->init_amp = ALC_INIT_GPIO3;
1324                 break;
1325         case 5:
1326                 spec->init_amp = ALC_INIT_DEFAULT;
1327                 break;
1328         }
1329
1330         /* is laptop or Desktop and enable the function "Mute internal speaker
1331          * when the external headphone out jack is plugged"
1332          */
1333         if (!(ass & 0x8000))
1334                 return 1;
1335         /*
1336          * 10~8 : Jack location
1337          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1338          * 14~13: Resvered
1339          * 15   : 1 --> enable the function "Mute internal speaker
1340          *              when the external headphone out jack is plugged"
1341          */
1342         if (!spec->autocfg.hp_pins[0]) {
1343                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1344                 if (tmp == 0)
1345                         spec->autocfg.hp_pins[0] = porta;
1346                 else if (tmp == 1)
1347                         spec->autocfg.hp_pins[0] = porte;
1348                 else if (tmp == 2)
1349                         spec->autocfg.hp_pins[0] = portd;
1350                 else
1351                         return 1;
1352         }
1353
1354         alc_init_auto_hp(codec);
1355         alc_init_auto_mic(codec);
1356         return 1;
1357 }
1358
1359 static void alc_ssid_check(struct hda_codec *codec,
1360                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1361 {
1362         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1363                 struct alc_spec *spec = codec->spec;
1364                 snd_printd("realtek: "
1365                            "Enable default setup for auto mode as fallback\n");
1366                 spec->init_amp = ALC_INIT_DEFAULT;
1367                 alc_init_auto_hp(codec);
1368                 alc_init_auto_mic(codec);
1369         }
1370 }
1371
1372 /*
1373  * Fix-up pin default configurations
1374  */
1375
1376 struct alc_pincfg {
1377         hda_nid_t nid;
1378         u32 val;
1379 };
1380
1381 static void alc_fix_pincfg(struct hda_codec *codec,
1382                            const struct snd_pci_quirk *quirk,
1383                            const struct alc_pincfg **pinfix)
1384 {
1385         const struct alc_pincfg *cfg;
1386
1387         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1388         if (!quirk)
1389                 return;
1390
1391         cfg = pinfix[quirk->value];
1392         for (; cfg->nid; cfg++)
1393                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1394 }
1395
1396 /*
1397  * ALC888
1398  */
1399
1400 /*
1401  * 2ch mode
1402  */
1403 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1404 /* Mic-in jack as mic in */
1405         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1406         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1407 /* Line-in jack as Line in */
1408         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1409         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1410 /* Line-Out as Front */
1411         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1412         { } /* end */
1413 };
1414
1415 /*
1416  * 4ch mode
1417  */
1418 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1419 /* Mic-in jack as mic in */
1420         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1421         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1422 /* Line-in jack as Surround */
1423         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1424         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1425 /* Line-Out as Front */
1426         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1427         { } /* end */
1428 };
1429
1430 /*
1431  * 6ch mode
1432  */
1433 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1434 /* Mic-in jack as CLFE */
1435         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1436         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1437 /* Line-in jack as Surround */
1438         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1439         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1440 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1441         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1442         { } /* end */
1443 };
1444
1445 /*
1446  * 8ch mode
1447  */
1448 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1449 /* Mic-in jack as CLFE */
1450         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1451         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1452 /* Line-in jack as Surround */
1453         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1454         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1455 /* Line-Out as Side */
1456         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1457         { } /* end */
1458 };
1459
1460 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1461         { 2, alc888_4ST_ch2_intel_init },
1462         { 4, alc888_4ST_ch4_intel_init },
1463         { 6, alc888_4ST_ch6_intel_init },
1464         { 8, alc888_4ST_ch8_intel_init },
1465 };
1466
1467 /*
1468  * ALC888 Fujitsu Siemens Amillo xa3530
1469  */
1470
1471 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1472 /* Front Mic: set to PIN_IN (empty by default) */
1473         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1474 /* Connect Internal HP to Front */
1475         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1476         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1477         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1478 /* Connect Bass HP to Front */
1479         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1480         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1481         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1482 /* Connect Line-Out side jack (SPDIF) to Side */
1483         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1484         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1485         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1486 /* Connect Mic jack to CLFE */
1487         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1488         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1489         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1490 /* Connect Line-in jack to Surround */
1491         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1492         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1493         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1494 /* Connect HP out jack to Front */
1495         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1496         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1497         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1498 /* Enable unsolicited event for HP jack and Line-out jack */
1499         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1500         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1501         {}
1502 };
1503
1504 static void alc_automute_amp(struct hda_codec *codec)
1505 {
1506         struct alc_spec *spec = codec->spec;
1507         unsigned int val, mute, pincap;
1508         hda_nid_t nid;
1509         int i;
1510
1511         spec->jack_present = 0;
1512         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1513                 nid = spec->autocfg.hp_pins[i];
1514                 if (!nid)
1515                         break;
1516                 pincap = snd_hda_query_pin_caps(codec, nid);
1517                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1518                         snd_hda_codec_read(codec, nid, 0,
1519                                            AC_VERB_SET_PIN_SENSE, 0);
1520                 val = snd_hda_codec_read(codec, nid, 0,
1521                                          AC_VERB_GET_PIN_SENSE, 0);
1522                 if (val & AC_PINSENSE_PRESENCE) {
1523                         spec->jack_present = 1;
1524                         break;
1525                 }
1526         }
1527
1528         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1529         /* Toggle internal speakers muting */
1530         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1531                 nid = spec->autocfg.speaker_pins[i];
1532                 if (!nid)
1533                         break;
1534                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1535                                          HDA_AMP_MUTE, mute);
1536         }
1537 }
1538
1539 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1540                                          unsigned int res)
1541 {
1542         if (codec->vendor_id == 0x10ec0880)
1543                 res >>= 28;
1544         else
1545                 res >>= 26;
1546         if (res == ALC880_HP_EVENT)
1547                 alc_automute_amp(codec);
1548 }
1549
1550 static void alc889_automute_init(struct hda_codec *codec)
1551 {
1552         struct alc_spec *spec = codec->spec;
1553
1554         spec->autocfg.hp_pins[0] = 0x15;
1555         spec->autocfg.speaker_pins[0] = 0x14;
1556         spec->autocfg.speaker_pins[1] = 0x16;
1557         spec->autocfg.speaker_pins[2] = 0x17;
1558         spec->autocfg.speaker_pins[3] = 0x19;
1559         spec->autocfg.speaker_pins[4] = 0x1a;
1560         alc_automute_amp(codec);
1561 }
1562
1563 static void alc889_intel_init_hook(struct hda_codec *codec)
1564 {
1565         alc889_coef_init(codec);
1566         alc889_automute_init(codec);
1567 }
1568
1569 static void alc888_fujitsu_xa3530_init_hook(struct hda_codec *codec)
1570 {
1571         struct alc_spec *spec = codec->spec;
1572
1573         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1574         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1575         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1576         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1577         alc_automute_amp(codec);
1578 }
1579
1580 /*
1581  * ALC888 Acer Aspire 4930G model
1582  */
1583
1584 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1585 /* Front Mic: set to PIN_IN (empty by default) */
1586         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1587 /* Unselect Front Mic by default in input mixer 3 */
1588         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1589 /* Enable unsolicited event for HP jack */
1590         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1591 /* Connect Internal HP to front */
1592         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1593         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1594         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1595 /* Connect HP out to front */
1596         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1597         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1598         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1599         { }
1600 };
1601
1602 /*
1603  * ALC888 Acer Aspire 6530G model
1604  */
1605
1606 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1607 /* Bias voltage on for external mic port */
1608         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1609 /* Front Mic: set to PIN_IN (empty by default) */
1610         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1611 /* Unselect Front Mic by default in input mixer 3 */
1612         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1613 /* Enable unsolicited event for HP jack */
1614         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1615 /* Enable speaker output */
1616         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1617         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1618 /* Enable headphone output */
1619         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1620         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1621         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1622         { }
1623 };
1624
1625 /*
1626  * ALC889 Acer Aspire 8930G model
1627  */
1628
1629 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1630 /* Front Mic: set to PIN_IN (empty by default) */
1631         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1632 /* Unselect Front Mic by default in input mixer 3 */
1633         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1634 /* Enable unsolicited event for HP jack */
1635         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1636 /* Connect Internal Front to Front */
1637         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1638         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1639         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1640 /* Connect Internal Rear to Rear */
1641         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1642         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1643         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1644 /* Connect Internal CLFE to CLFE */
1645         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1646         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1647         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1648 /* Connect HP out to Front */
1649         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1650         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1651         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1652 /* Enable all DACs */
1653 /*  DAC DISABLE/MUTE 1? */
1654 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1655         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1656         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1657 /*  DAC DISABLE/MUTE 2? */
1658 /*  some bit here disables the other DACs. Init=0x4900 */
1659         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1660         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1661 /* Enable amplifiers */
1662         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1663         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1664 /* DMIC fix
1665  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1666  * which makes the stereo useless. However, either the mic or the ALC889
1667  * makes the signal become a difference/sum signal instead of standard
1668  * stereo, which is annoying. So instead we flip this bit which makes the
1669  * codec replicate the sum signal to both channels, turning it into a
1670  * normal mono mic.
1671  */
1672 /*  DMIC_CONTROL? Init value = 0x0001 */
1673         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1674         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1675         { }
1676 };
1677
1678 static struct hda_input_mux alc888_2_capture_sources[2] = {
1679         /* Front mic only available on one ADC */
1680         {
1681                 .num_items = 4,
1682                 .items = {
1683                         { "Mic", 0x0 },
1684                         { "Line", 0x2 },
1685                         { "CD", 0x4 },
1686                         { "Front Mic", 0xb },
1687                 },
1688         },
1689         {
1690                 .num_items = 3,
1691                 .items = {
1692                         { "Mic", 0x0 },
1693                         { "Line", 0x2 },
1694                         { "CD", 0x4 },
1695                 },
1696         }
1697 };
1698
1699 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1700         /* Interal mic only available on one ADC */
1701         {
1702                 .num_items = 5,
1703                 .items = {
1704                         { "Ext Mic", 0x0 },
1705                         { "Line In", 0x2 },
1706                         { "CD", 0x4 },
1707                         { "Input Mix", 0xa },
1708                         { "Int Mic", 0xb },
1709                 },
1710         },
1711         {
1712                 .num_items = 4,
1713                 .items = {
1714                         { "Ext Mic", 0x0 },
1715                         { "Line In", 0x2 },
1716                         { "CD", 0x4 },
1717                         { "Input Mix", 0xa },
1718                 },
1719         }
1720 };
1721
1722 static struct hda_input_mux alc889_capture_sources[3] = {
1723         /* Digital mic only available on first "ADC" */
1724         {
1725                 .num_items = 5,
1726                 .items = {
1727                         { "Mic", 0x0 },
1728                         { "Line", 0x2 },
1729                         { "CD", 0x4 },
1730                         { "Front Mic", 0xb },
1731                         { "Input Mix", 0xa },
1732                 },
1733         },
1734         {
1735                 .num_items = 4,
1736                 .items = {
1737                         { "Mic", 0x0 },
1738                         { "Line", 0x2 },
1739                         { "CD", 0x4 },
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
1754 static struct snd_kcontrol_new alc888_base_mixer[] = {
1755         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1756         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1757         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1758         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1759         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1760                 HDA_OUTPUT),
1761         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1762         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1763         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1764         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1765         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1766         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1767         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1768         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1769         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1770         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1771         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1772         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1773         { } /* end */
1774 };
1775
1776 static void alc888_acer_aspire_4930g_init_hook(struct hda_codec *codec)
1777 {
1778         struct alc_spec *spec = codec->spec;
1779
1780         spec->autocfg.hp_pins[0] = 0x15;
1781         spec->autocfg.speaker_pins[0] = 0x14;
1782         alc_automute_amp(codec);
1783 }
1784
1785 static void alc888_acer_aspire_6530g_init_hook(struct hda_codec *codec)
1786 {
1787         struct alc_spec *spec = codec->spec;
1788
1789         spec->autocfg.hp_pins[0] = 0x15;
1790         spec->autocfg.speaker_pins[0] = 0x14;
1791         spec->autocfg.speaker_pins[1] = 0x16;
1792         spec->autocfg.speaker_pins[2] = 0x17;
1793         alc_automute_amp(codec);
1794 }
1795
1796 static void alc889_acer_aspire_8930g_init_hook(struct hda_codec *codec)
1797 {
1798         struct alc_spec *spec = codec->spec;
1799
1800         spec->autocfg.hp_pins[0] = 0x15;
1801         spec->autocfg.speaker_pins[0] = 0x14;
1802         spec->autocfg.speaker_pins[1] = 0x16;
1803         spec->autocfg.speaker_pins[2] = 0x1b;
1804         alc_automute_amp(codec);
1805 }
1806
1807 /*
1808  * ALC880 3-stack model
1809  *
1810  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1811  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1812  *                 F-Mic = 0x1b, HP = 0x19
1813  */
1814
1815 static hda_nid_t alc880_dac_nids[4] = {
1816         /* front, rear, clfe, rear_surr */
1817         0x02, 0x05, 0x04, 0x03
1818 };
1819
1820 static hda_nid_t alc880_adc_nids[3] = {
1821         /* ADC0-2 */
1822         0x07, 0x08, 0x09,
1823 };
1824
1825 /* The datasheet says the node 0x07 is connected from inputs,
1826  * but it shows zero connection in the real implementation on some devices.
1827  * Note: this is a 915GAV bug, fixed on 915GLV
1828  */
1829 static hda_nid_t alc880_adc_nids_alt[2] = {
1830         /* ADC1-2 */
1831         0x08, 0x09,
1832 };
1833
1834 #define ALC880_DIGOUT_NID       0x06
1835 #define ALC880_DIGIN_NID        0x0a
1836
1837 static struct hda_input_mux alc880_capture_source = {
1838         .num_items = 4,
1839         .items = {
1840                 { "Mic", 0x0 },
1841                 { "Front Mic", 0x3 },
1842                 { "Line", 0x2 },
1843                 { "CD", 0x4 },
1844         },
1845 };
1846
1847 /* channel source setting (2/6 channel selection for 3-stack) */
1848 /* 2ch mode */
1849 static struct hda_verb alc880_threestack_ch2_init[] = {
1850         /* set line-in to input, mute it */
1851         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1852         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1853         /* set mic-in to input vref 80%, mute it */
1854         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1855         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1856         { } /* end */
1857 };
1858
1859 /* 6ch mode */
1860 static struct hda_verb alc880_threestack_ch6_init[] = {
1861         /* set line-in to output, unmute it */
1862         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1863         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1864         /* set mic-in to output, unmute it */
1865         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1866         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1867         { } /* end */
1868 };
1869
1870 static struct hda_channel_mode alc880_threestack_modes[2] = {
1871         { 2, alc880_threestack_ch2_init },
1872         { 6, alc880_threestack_ch6_init },
1873 };
1874
1875 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1876         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1877         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1878         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1879         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1880         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1881         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1882         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1883         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1884         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1885         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1886         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1887         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1888         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1889         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1890         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1891         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1892         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1893         {
1894                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1895                 .name = "Channel Mode",
1896                 .info = alc_ch_mode_info,
1897                 .get = alc_ch_mode_get,
1898                 .put = alc_ch_mode_put,
1899         },
1900         { } /* end */
1901 };
1902
1903 /* capture mixer elements */
1904 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1905                             struct snd_ctl_elem_info *uinfo)
1906 {
1907         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1908         struct alc_spec *spec = codec->spec;
1909         int err;
1910
1911         mutex_lock(&codec->control_mutex);
1912         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1913                                                       HDA_INPUT);
1914         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1915         mutex_unlock(&codec->control_mutex);
1916         return err;
1917 }
1918
1919 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1920                            unsigned int size, unsigned int __user *tlv)
1921 {
1922         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1923         struct alc_spec *spec = codec->spec;
1924         int err;
1925
1926         mutex_lock(&codec->control_mutex);
1927         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1928                                                       HDA_INPUT);
1929         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1930         mutex_unlock(&codec->control_mutex);
1931         return err;
1932 }
1933
1934 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1935                              struct snd_ctl_elem_value *ucontrol);
1936
1937 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1938                                  struct snd_ctl_elem_value *ucontrol,
1939                                  getput_call_t func)
1940 {
1941         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1942         struct alc_spec *spec = codec->spec;
1943         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1944         int err;
1945
1946         mutex_lock(&codec->control_mutex);
1947         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1948                                                       3, 0, HDA_INPUT);
1949         err = func(kcontrol, ucontrol);
1950         mutex_unlock(&codec->control_mutex);
1951         return err;
1952 }
1953
1954 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1955                            struct snd_ctl_elem_value *ucontrol)
1956 {
1957         return alc_cap_getput_caller(kcontrol, ucontrol,
1958                                      snd_hda_mixer_amp_volume_get);
1959 }
1960
1961 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1962                            struct snd_ctl_elem_value *ucontrol)
1963 {
1964         return alc_cap_getput_caller(kcontrol, ucontrol,
1965                                      snd_hda_mixer_amp_volume_put);
1966 }
1967
1968 /* capture mixer elements */
1969 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1970
1971 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1972                           struct snd_ctl_elem_value *ucontrol)
1973 {
1974         return alc_cap_getput_caller(kcontrol, ucontrol,
1975                                      snd_hda_mixer_amp_switch_get);
1976 }
1977
1978 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1979                           struct snd_ctl_elem_value *ucontrol)
1980 {
1981         return alc_cap_getput_caller(kcontrol, ucontrol,
1982                                      snd_hda_mixer_amp_switch_put);
1983 }
1984
1985 #define _DEFINE_CAPMIX(num) \
1986         { \
1987                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1988                 .name = "Capture Switch", \
1989                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1990                 .count = num, \
1991                 .info = alc_cap_sw_info, \
1992                 .get = alc_cap_sw_get, \
1993                 .put = alc_cap_sw_put, \
1994         }, \
1995         { \
1996                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1997                 .name = "Capture Volume", \
1998                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
1999                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2000                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2001                 .count = num, \
2002                 .info = alc_cap_vol_info, \
2003                 .get = alc_cap_vol_get, \
2004                 .put = alc_cap_vol_put, \
2005                 .tlv = { .c = alc_cap_vol_tlv }, \
2006         }
2007
2008 #define _DEFINE_CAPSRC(num) \
2009         { \
2010                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2011                 /* .name = "Capture Source", */ \
2012                 .name = "Input Source", \
2013                 .count = num, \
2014                 .info = alc_mux_enum_info, \
2015                 .get = alc_mux_enum_get, \
2016                 .put = alc_mux_enum_put, \
2017         }
2018
2019 #define DEFINE_CAPMIX(num) \
2020 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2021         _DEFINE_CAPMIX(num),                                  \
2022         _DEFINE_CAPSRC(num),                                  \
2023         { } /* end */                                         \
2024 }
2025
2026 #define DEFINE_CAPMIX_NOSRC(num) \
2027 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2028         _DEFINE_CAPMIX(num),                                        \
2029         { } /* end */                                               \
2030 }
2031
2032 /* up to three ADCs */
2033 DEFINE_CAPMIX(1);
2034 DEFINE_CAPMIX(2);
2035 DEFINE_CAPMIX(3);
2036 DEFINE_CAPMIX_NOSRC(1);
2037 DEFINE_CAPMIX_NOSRC(2);
2038 DEFINE_CAPMIX_NOSRC(3);
2039
2040 /*
2041  * ALC880 5-stack model
2042  *
2043  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2044  *      Side = 0x02 (0xd)
2045  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2046  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2047  */
2048
2049 /* additional mixers to alc880_three_stack_mixer */
2050 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2051         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2052         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2053         { } /* end */
2054 };
2055
2056 /* channel source setting (6/8 channel selection for 5-stack) */
2057 /* 6ch mode */
2058 static struct hda_verb alc880_fivestack_ch6_init[] = {
2059         /* set line-in to input, mute it */
2060         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2061         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2062         { } /* end */
2063 };
2064
2065 /* 8ch mode */
2066 static struct hda_verb alc880_fivestack_ch8_init[] = {
2067         /* set line-in to output, unmute it */
2068         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2069         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2070         { } /* end */
2071 };
2072
2073 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2074         { 6, alc880_fivestack_ch6_init },
2075         { 8, alc880_fivestack_ch8_init },
2076 };
2077
2078
2079 /*
2080  * ALC880 6-stack model
2081  *
2082  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2083  *      Side = 0x05 (0x0f)
2084  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2085  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2086  */
2087
2088 static hda_nid_t alc880_6st_dac_nids[4] = {
2089         /* front, rear, clfe, rear_surr */
2090         0x02, 0x03, 0x04, 0x05
2091 };
2092
2093 static struct hda_input_mux alc880_6stack_capture_source = {
2094         .num_items = 4,
2095         .items = {
2096                 { "Mic", 0x0 },
2097                 { "Front Mic", 0x1 },
2098                 { "Line", 0x2 },
2099                 { "CD", 0x4 },
2100         },
2101 };
2102
2103 /* fixed 8-channels */
2104 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2105         { 8, NULL },
2106 };
2107
2108 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2109         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2110         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2111         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2112         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2113         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2114         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2115         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2116         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2117         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2118         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2119         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2120         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2121         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2122         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2123         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2124         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2125         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2126         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2127         {
2128                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2129                 .name = "Channel Mode",
2130                 .info = alc_ch_mode_info,
2131                 .get = alc_ch_mode_get,
2132                 .put = alc_ch_mode_put,
2133         },
2134         { } /* end */
2135 };
2136
2137
2138 /*
2139  * ALC880 W810 model
2140  *
2141  * W810 has rear IO for:
2142  * Front (DAC 02)
2143  * Surround (DAC 03)
2144  * Center/LFE (DAC 04)
2145  * Digital out (06)
2146  *
2147  * The system also has a pair of internal speakers, and a headphone jack.
2148  * These are both connected to Line2 on the codec, hence to DAC 02.
2149  *
2150  * There is a variable resistor to control the speaker or headphone
2151  * volume. This is a hardware-only device without a software API.
2152  *
2153  * Plugging headphones in will disable the internal speakers. This is
2154  * implemented in hardware, not via the driver using jack sense. In
2155  * a similar fashion, plugging into the rear socket marked "front" will
2156  * disable both the speakers and headphones.
2157  *
2158  * For input, there's a microphone jack, and an "audio in" jack.
2159  * These may not do anything useful with this driver yet, because I
2160  * haven't setup any initialization verbs for these yet...
2161  */
2162
2163 static hda_nid_t alc880_w810_dac_nids[3] = {
2164         /* front, rear/surround, clfe */
2165         0x02, 0x03, 0x04
2166 };
2167
2168 /* fixed 6 channels */
2169 static struct hda_channel_mode alc880_w810_modes[1] = {
2170         { 6, NULL }
2171 };
2172
2173 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2174 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2175         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2176         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2177         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2178         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2179         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2180         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2181         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2182         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2183         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2184         { } /* end */
2185 };
2186
2187
2188 /*
2189  * Z710V model
2190  *
2191  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2192  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2193  *                 Line = 0x1a
2194  */
2195
2196 static hda_nid_t alc880_z71v_dac_nids[1] = {
2197         0x02
2198 };
2199 #define ALC880_Z71V_HP_DAC      0x03
2200
2201 /* fixed 2 channels */
2202 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2203         { 2, NULL }
2204 };
2205
2206 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2207         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2208         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2209         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2210         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2211         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2212         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2213         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2214         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2215         { } /* end */
2216 };
2217
2218
2219 /*
2220  * ALC880 F1734 model
2221  *
2222  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2223  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2224  */
2225
2226 static hda_nid_t alc880_f1734_dac_nids[1] = {
2227         0x03
2228 };
2229 #define ALC880_F1734_HP_DAC     0x02
2230
2231 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2232         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2233         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2234         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2235         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2236         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2237         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2238         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2239         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2240         { } /* end */
2241 };
2242
2243 static struct hda_input_mux alc880_f1734_capture_source = {
2244         .num_items = 2,
2245         .items = {
2246                 { "Mic", 0x1 },
2247                 { "CD", 0x4 },
2248         },
2249 };
2250
2251
2252 /*
2253  * ALC880 ASUS model
2254  *
2255  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2256  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2257  *  Mic = 0x18, Line = 0x1a
2258  */
2259
2260 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2261 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2262
2263 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2264         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2265         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2266         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2267         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2268         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2269         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2270         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2271         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2272         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2273         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2274         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2275         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2276         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2277         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2278         {
2279                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2280                 .name = "Channel Mode",
2281                 .info = alc_ch_mode_info,
2282                 .get = alc_ch_mode_get,
2283                 .put = alc_ch_mode_put,
2284         },
2285         { } /* end */
2286 };
2287
2288 /*
2289  * ALC880 ASUS W1V model
2290  *
2291  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2292  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2293  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2294  */
2295
2296 /* additional mixers to alc880_asus_mixer */
2297 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2298         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2299         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2300         { } /* end */
2301 };
2302
2303 /* TCL S700 */
2304 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2305         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2306         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2307         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2308         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2309         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2310         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2311         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2312         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2313         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2314         { } /* end */
2315 };
2316
2317 /* Uniwill */
2318 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2319         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2320         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2321         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2322         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2323         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2324         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2325         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2326         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2327         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2328         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2329         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2330         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2331         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2332         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2333         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2334         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2335         {
2336                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2337                 .name = "Channel Mode",
2338                 .info = alc_ch_mode_info,
2339                 .get = alc_ch_mode_get,
2340                 .put = alc_ch_mode_put,
2341         },
2342         { } /* end */
2343 };
2344
2345 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2346         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2347         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2348         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2349         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2350         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2351         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2352         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2353         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2354         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2355         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2356         { } /* end */
2357 };
2358
2359 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2360         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2361         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2362         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2363         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2364         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2365         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2366         { } /* end */
2367 };
2368
2369 /*
2370  * virtual master controls
2371  */
2372
2373 /*
2374  * slave controls for virtual master
2375  */
2376 static const char *alc_slave_vols[] = {
2377         "Front Playback Volume",
2378         "Surround Playback Volume",
2379         "Center Playback Volume",
2380         "LFE Playback Volume",
2381         "Side Playback Volume",
2382         "Headphone Playback Volume",
2383         "Speaker Playback Volume",
2384         "Mono Playback Volume",
2385         "Line-Out Playback Volume",
2386         "PCM Playback Volume",
2387         NULL,
2388 };
2389
2390 static const char *alc_slave_sws[] = {
2391         "Front Playback Switch",
2392         "Surround Playback Switch",
2393         "Center Playback Switch",
2394         "LFE Playback Switch",
2395         "Side Playback Switch",
2396         "Headphone Playback Switch",
2397         "Speaker Playback Switch",
2398         "Mono Playback Switch",
2399         "IEC958 Playback Switch",
2400         NULL,
2401 };
2402
2403 /*
2404  * build control elements
2405  */
2406
2407 static void alc_free_kctls(struct hda_codec *codec);
2408
2409 /* additional beep mixers; the actual parameters are overwritten at build */
2410 static struct snd_kcontrol_new alc_beep_mixer[] = {
2411         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2412         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2413         { } /* end */
2414 };
2415
2416 static int alc_build_controls(struct hda_codec *codec)
2417 {
2418         struct alc_spec *spec = codec->spec;
2419         int err;
2420         int i;
2421
2422         for (i = 0; i < spec->num_mixers; i++) {
2423                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2424                 if (err < 0)
2425                         return err;
2426         }
2427         if (spec->cap_mixer) {
2428                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2429                 if (err < 0)
2430                         return err;
2431         }
2432         if (spec->multiout.dig_out_nid) {
2433                 err = snd_hda_create_spdif_out_ctls(codec,
2434                                                     spec->multiout.dig_out_nid);
2435                 if (err < 0)
2436                         return err;
2437                 if (!spec->no_analog) {
2438                         err = snd_hda_create_spdif_share_sw(codec,
2439                                                             &spec->multiout);
2440                         if (err < 0)
2441                                 return err;
2442                         spec->multiout.share_spdif = 1;
2443                 }
2444         }
2445         if (spec->dig_in_nid) {
2446                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2447                 if (err < 0)
2448                         return err;
2449         }
2450
2451         /* create beep controls if needed */
2452         if (spec->beep_amp) {
2453                 struct snd_kcontrol_new *knew;
2454                 for (knew = alc_beep_mixer; knew->name; knew++) {
2455                         struct snd_kcontrol *kctl;
2456                         kctl = snd_ctl_new1(knew, codec);
2457                         if (!kctl)
2458                                 return -ENOMEM;
2459                         kctl->private_value = spec->beep_amp;
2460                         err = snd_hda_ctl_add(codec, kctl);
2461                         if (err < 0)
2462                                 return err;
2463                 }
2464         }
2465
2466         /* if we have no master control, let's create it */
2467         if (!spec->no_analog &&
2468             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2469                 unsigned int vmaster_tlv[4];
2470                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2471                                         HDA_OUTPUT, vmaster_tlv);
2472                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2473                                           vmaster_tlv, alc_slave_vols);
2474                 if (err < 0)
2475                         return err;
2476         }
2477         if (!spec->no_analog &&
2478             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2479                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2480                                           NULL, alc_slave_sws);
2481                 if (err < 0)
2482                         return err;
2483         }
2484
2485         alc_free_kctls(codec); /* no longer needed */
2486         return 0;
2487 }
2488
2489
2490 /*
2491  * initialize the codec volumes, etc
2492  */
2493
2494 /*
2495  * generic initialization of ADC, input mixers and output mixers
2496  */
2497 static struct hda_verb alc880_volume_init_verbs[] = {
2498         /*
2499          * Unmute ADC0-2 and set the default input to mic-in
2500          */
2501         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2502         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2503         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2505         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2506         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2507
2508         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2509          * mixer widget
2510          * Note: PASD motherboards uses the Line In 2 as the input for front
2511          * panel mic (mic 2)
2512          */
2513         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2514         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2515         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2516         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2517         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2518         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2519         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2520         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2521
2522         /*
2523          * Set up output mixers (0x0c - 0x0f)
2524          */
2525         /* set vol=0 to output mixers */
2526         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2527         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2528         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2529         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2530         /* set up input amps for analog loopback */
2531         /* Amp Indices: DAC = 0, mixer = 1 */
2532         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2533         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2534         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2535         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2536         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2537         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2538         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2539         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2540
2541         { }
2542 };
2543
2544 /*
2545  * 3-stack pin configuration:
2546  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2547  */
2548 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2549         /*
2550          * preset connection lists of input pins
2551          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2552          */
2553         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2554         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2555         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2556
2557         /*
2558          * Set pin mode and muting
2559          */
2560         /* set front pin widgets 0x14 for output */
2561         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2562         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2563         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2564         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2565         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2566         /* Mic2 (as headphone out) for HP output */
2567         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2568         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2569         /* Line In pin widget for input */
2570         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2571         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2572         /* Line2 (as front mic) pin widget for input and vref at 80% */
2573         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2574         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2575         /* CD pin widget for input */
2576         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2577
2578         { }
2579 };
2580
2581 /*
2582  * 5-stack pin configuration:
2583  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2584  * line-in/side = 0x1a, f-mic = 0x1b
2585  */
2586 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2587         /*
2588          * preset connection lists of input pins
2589          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2590          */
2591         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2592         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2593
2594         /*
2595          * Set pin mode and muting
2596          */
2597         /* set pin widgets 0x14-0x17 for output */
2598         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2599         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2600         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2601         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2602         /* unmute pins for output (no gain on this amp) */
2603         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2604         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2605         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2606         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607
2608         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2609         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2610         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2611         /* Mic2 (as headphone out) for HP output */
2612         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2613         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2614         /* Line In pin widget for input */
2615         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2616         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2617         /* Line2 (as front mic) pin widget for input and vref at 80% */
2618         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2619         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2620         /* CD pin widget for input */
2621         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2622
2623         { }
2624 };
2625
2626 /*
2627  * W810 pin configuration:
2628  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2629  */
2630 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2631         /* hphone/speaker input selector: front DAC */
2632         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2633
2634         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2635         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2636         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2637         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2638         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2639         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2640
2641         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2642         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2643
2644         { }
2645 };
2646
2647 /*
2648  * Z71V pin configuration:
2649  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2650  */
2651 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2652         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2653         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2654         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2655         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2656
2657         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2658         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2659         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2660         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2661
2662         { }
2663 };
2664
2665 /*
2666  * 6-stack pin configuration:
2667  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2668  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2669  */
2670 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2671         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2672
2673         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2674         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2676         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2677         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2678         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2679         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2680         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2681
2682         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2683         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2684         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2685         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2686         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2687         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2688         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2689         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2690         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2691
2692         { }
2693 };
2694
2695 /*
2696  * Uniwill pin configuration:
2697  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2698  * line = 0x1a
2699  */
2700 static struct hda_verb alc880_uniwill_init_verbs[] = {
2701         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2702
2703         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2704         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2705         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2706         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2707         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2708         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2709         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2710         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2711         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2712         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2713         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2714         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2715         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2716         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2717
2718         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2719         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2720         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2721         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2722         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2723         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2724         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2725         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2726         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2727
2728         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2729         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2730
2731         { }
2732 };
2733
2734 /*
2735 * Uniwill P53
2736 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2737  */
2738 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2739         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2740
2741         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2742         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2743         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2744         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2745         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2746         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2747         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2748         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2749         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2750         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2751         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2752         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2753
2754         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2755         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2756         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2757         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2758         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2759         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2760
2761         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2762         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2763
2764         { }
2765 };
2766
2767 static struct hda_verb alc880_beep_init_verbs[] = {
2768         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2769         { }
2770 };
2771
2772 /* auto-toggle front mic */
2773 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2774 {
2775         unsigned int present;
2776         unsigned char bits;
2777
2778         present = snd_hda_codec_read(codec, 0x18, 0,
2779                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2780         bits = present ? HDA_AMP_MUTE : 0;
2781         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2782 }
2783
2784 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2785 {
2786         struct alc_spec *spec = codec->spec;
2787
2788         spec->autocfg.hp_pins[0] = 0x14;
2789         spec->autocfg.speaker_pins[0] = 0x15;
2790         spec->autocfg.speaker_pins[0] = 0x16;
2791         alc_automute_amp(codec);
2792         alc880_uniwill_mic_automute(codec);
2793 }
2794
2795 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2796                                        unsigned int res)
2797 {
2798         /* Looks like the unsol event is incompatible with the standard
2799          * definition.  4bit tag is placed at 28 bit!
2800          */
2801         switch (res >> 28) {
2802         case ALC880_MIC_EVENT:
2803                 alc880_uniwill_mic_automute(codec);
2804                 break;
2805         default:
2806                 alc_automute_amp_unsol_event(codec, res);
2807                 break;
2808         }
2809 }
2810
2811 static void alc880_uniwill_p53_init_hook(struct hda_codec *codec)
2812 {
2813         struct alc_spec *spec = codec->spec;
2814
2815         spec->autocfg.hp_pins[0] = 0x14;
2816         spec->autocfg.speaker_pins[0] = 0x15;
2817         alc_automute_amp(codec);
2818 }
2819
2820 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2821 {
2822         unsigned int present;
2823
2824         present = snd_hda_codec_read(codec, 0x21, 0,
2825                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2826         present &= HDA_AMP_VOLMASK;
2827         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2828                                  HDA_AMP_VOLMASK, present);
2829         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2830                                  HDA_AMP_VOLMASK, present);
2831 }
2832
2833 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2834                                            unsigned int res)
2835 {
2836         /* Looks like the unsol event is incompatible with the standard
2837          * definition.  4bit tag is placed at 28 bit!
2838          */
2839         if ((res >> 28) == ALC880_DCVOL_EVENT)
2840                 alc880_uniwill_p53_dcvol_automute(codec);
2841         else
2842                 alc_automute_amp_unsol_event(codec, res);
2843 }
2844
2845 /*
2846  * F1734 pin configuration:
2847  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2848  */
2849 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2850         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2851         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2852         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2853         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2854         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2855
2856         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2857         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2858         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2859         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2860
2861         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2862         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2863         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2864         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2865         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2866         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2867         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2868         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2869         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2870
2871         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2872         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2873
2874         { }
2875 };
2876
2877 /*
2878  * ASUS pin configuration:
2879  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2880  */
2881 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2882         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2883         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2884         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2885         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2886
2887         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2888         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2889         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2890         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2891         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2892         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2893         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2894         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2895
2896         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2897         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2898         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2899         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2900         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2901         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2902         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2903         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2904         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2905
2906         { }
2907 };
2908
2909 /* Enable GPIO mask and set output */
2910 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2911 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2912 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2913
2914 /* Clevo m520g init */
2915 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2916         /* headphone output */
2917         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2918         /* line-out */
2919         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2920         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2921         /* Line-in */
2922         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2923         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2924         /* CD */
2925         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2926         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2927         /* Mic1 (rear panel) */
2928         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2929         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2930         /* Mic2 (front panel) */
2931         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2932         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2933         /* headphone */
2934         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2935         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2936         /* change to EAPD mode */
2937         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2938         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2939
2940         { }
2941 };
2942
2943 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2944         /* change to EAPD mode */
2945         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2946         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2947
2948         /* Headphone output */
2949         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2950         /* Front output*/
2951         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2952         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2953
2954         /* Line In pin widget for input */
2955         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2956         /* CD pin widget for input */
2957         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2958         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2959         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2960
2961         /* change to EAPD mode */
2962         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2963         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2964
2965         { }
2966 };
2967
2968 /*
2969  * LG m1 express dual
2970  *
2971  * Pin assignment:
2972  *   Rear Line-In/Out (blue): 0x14
2973  *   Build-in Mic-In: 0x15
2974  *   Speaker-out: 0x17
2975  *   HP-Out (green): 0x1b
2976  *   Mic-In/Out (red): 0x19
2977  *   SPDIF-Out: 0x1e
2978  */
2979
2980 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2981 static hda_nid_t alc880_lg_dac_nids[3] = {
2982         0x05, 0x02, 0x03
2983 };
2984
2985 /* seems analog CD is not working */
2986 static struct hda_input_mux alc880_lg_capture_source = {
2987         .num_items = 3,
2988         .items = {
2989                 { "Mic", 0x1 },
2990                 { "Line", 0x5 },
2991                 { "Internal Mic", 0x6 },
2992         },
2993 };
2994
2995 /* 2,4,6 channel modes */
2996 static struct hda_verb alc880_lg_ch2_init[] = {
2997         /* set line-in and mic-in to input */
2998         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2999         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3000         { }
3001 };
3002
3003 static struct hda_verb alc880_lg_ch4_init[] = {
3004         /* set line-in to out and mic-in to input */
3005         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3006         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3007         { }
3008 };
3009
3010 static struct hda_verb alc880_lg_ch6_init[] = {
3011         /* set line-in and mic-in to output */
3012         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3013         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3014         { }
3015 };
3016
3017 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3018         { 2, alc880_lg_ch2_init },
3019         { 4, alc880_lg_ch4_init },
3020         { 6, alc880_lg_ch6_init },
3021 };
3022
3023 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3024         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3025         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3026         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3027         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3028         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3029         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3030         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3031         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3032         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3033         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3034         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3035         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3036         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3037         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3038         {
3039                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3040                 .name = "Channel Mode",
3041                 .info = alc_ch_mode_info,
3042                 .get = alc_ch_mode_get,
3043                 .put = alc_ch_mode_put,
3044         },
3045         { } /* end */
3046 };
3047
3048 static struct hda_verb alc880_lg_init_verbs[] = {
3049         /* set capture source to mic-in */
3050         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3051         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3052         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3053         /* mute all amp mixer inputs */
3054         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3055         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3056         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3057         /* line-in to input */
3058         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3059         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3060         /* built-in mic */
3061         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3062         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3063         /* speaker-out */
3064         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3065         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3066         /* mic-in to input */
3067         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3068         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3069         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3070         /* HP-out */
3071         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3072         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3073         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3074         /* jack sense */
3075         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3076         { }
3077 };
3078
3079 /* toggle speaker-output according to the hp-jack state */
3080 static void alc880_lg_init_hook(struct hda_codec *codec)
3081 {
3082         struct alc_spec *spec = codec->spec;
3083
3084         spec->autocfg.hp_pins[0] = 0x1b;
3085         spec->autocfg.speaker_pins[0] = 0x17;
3086         alc_automute_amp(codec);
3087 }
3088
3089 /*
3090  * LG LW20
3091  *
3092  * Pin assignment:
3093  *   Speaker-out: 0x14
3094  *   Mic-In: 0x18
3095  *   Built-in Mic-In: 0x19
3096  *   Line-In: 0x1b
3097  *   HP-Out: 0x1a
3098  *   SPDIF-Out: 0x1e
3099  */
3100
3101 static struct hda_input_mux alc880_lg_lw_capture_source = {
3102         .num_items = 3,
3103         .items = {
3104                 { "Mic", 0x0 },
3105                 { "Internal Mic", 0x1 },
3106                 { "Line In", 0x2 },
3107         },
3108 };
3109
3110 #define alc880_lg_lw_modes alc880_threestack_modes
3111
3112 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3113         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3114         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3115         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3116         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3117         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3118         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3119         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3120         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3121         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3122         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3123         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3124         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3125         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3126         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3127         {
3128                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3129                 .name = "Channel Mode",
3130                 .info = alc_ch_mode_info,
3131                 .get = alc_ch_mode_get,
3132                 .put = alc_ch_mode_put,
3133         },
3134         { } /* end */
3135 };
3136
3137 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3138         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3139         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3140         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3141
3142         /* set capture source to mic-in */
3143         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3144         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3145         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3146         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3147         /* speaker-out */
3148         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3149         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3150         /* HP-out */
3151         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3152         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3153         /* mic-in to input */
3154         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3155         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3156         /* built-in mic */
3157         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3158         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3159         /* jack sense */
3160         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3161         { }
3162 };
3163
3164 /* toggle speaker-output according to the hp-jack state */
3165 static void alc880_lg_lw_init_hook(struct hda_codec *codec)
3166 {
3167         struct alc_spec *spec = codec->spec;
3168
3169         spec->autocfg.hp_pins[0] = 0x1b;
3170         spec->autocfg.speaker_pins[0] = 0x14;
3171         alc_automute_amp(codec);
3172 }
3173
3174 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3175         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3176         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3177         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3178         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3179         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3180         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3181         { } /* end */
3182 };
3183
3184 static struct hda_input_mux alc880_medion_rim_capture_source = {
3185         .num_items = 2,
3186         .items = {
3187                 { "Mic", 0x0 },
3188                 { "Internal Mic", 0x1 },
3189         },
3190 };
3191
3192 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3193         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3194
3195         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3196         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3197
3198         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3199         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3200         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3201         /* Mic2 (as headphone out) for HP output */
3202         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3203         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3204         /* Internal Speaker */
3205         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3206         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3207
3208         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3209         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3210
3211         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3212         { }
3213 };
3214
3215 /* toggle speaker-output according to the hp-jack state */
3216 static void alc880_medion_rim_automute(struct hda_codec *codec)
3217 {
3218         struct alc_spec *spec = codec->spec;
3219         alc_automute_amp(codec);
3220         /* toggle EAPD */
3221         if (spec->jack_present)
3222                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3223         else
3224                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3225 }
3226
3227 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3228                                           unsigned int res)
3229 {
3230         /* Looks like the unsol event is incompatible with the standard
3231          * definition.  4bit tag is placed at 28 bit!
3232          */
3233         if ((res >> 28) == ALC880_HP_EVENT)
3234                 alc880_medion_rim_automute(codec);
3235 }
3236
3237 static void alc880_medion_rim_init_hook(struct hda_codec *codec)
3238 {
3239         struct alc_spec *spec = codec->spec;
3240
3241         spec->autocfg.hp_pins[0] = 0x14;
3242         spec->autocfg.speaker_pins[0] = 0x1b;
3243         alc880_medion_rim_automute(codec);
3244 }
3245
3246 #ifdef CONFIG_SND_HDA_POWER_SAVE
3247 static struct hda_amp_list alc880_loopbacks[] = {
3248         { 0x0b, HDA_INPUT, 0 },
3249         { 0x0b, HDA_INPUT, 1 },
3250         { 0x0b, HDA_INPUT, 2 },
3251         { 0x0b, HDA_INPUT, 3 },
3252         { 0x0b, HDA_INPUT, 4 },
3253         { } /* end */
3254 };
3255
3256 static struct hda_amp_list alc880_lg_loopbacks[] = {
3257         { 0x0b, HDA_INPUT, 1 },
3258         { 0x0b, HDA_INPUT, 6 },
3259         { 0x0b, HDA_INPUT, 7 },
3260         { } /* end */
3261 };
3262 #endif
3263
3264 /*
3265  * Common callbacks
3266  */
3267
3268 static int alc_init(struct hda_codec *codec)
3269 {
3270         struct alc_spec *spec = codec->spec;
3271         unsigned int i;
3272
3273         alc_fix_pll(codec);
3274         alc_auto_init_amp(codec, spec->init_amp);
3275
3276         for (i = 0; i < spec->num_init_verbs; i++)
3277                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3278
3279         if (spec->init_hook)
3280                 spec->init_hook(codec);
3281
3282         return 0;
3283 }
3284
3285 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3286 {
3287         struct alc_spec *spec = codec->spec;
3288
3289         if (spec->unsol_event)
3290                 spec->unsol_event(codec, res);
3291 }
3292
3293 #ifdef CONFIG_SND_HDA_POWER_SAVE
3294 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3295 {
3296         struct alc_spec *spec = codec->spec;
3297         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3298 }
3299 #endif
3300
3301 /*
3302  * Analog playback callbacks
3303  */
3304 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3305                                     struct hda_codec *codec,
3306                                     struct snd_pcm_substream *substream)
3307 {
3308         struct alc_spec *spec = codec->spec;
3309         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3310                                              hinfo);
3311 }
3312
3313 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3314                                        struct hda_codec *codec,
3315                                        unsigned int stream_tag,
3316                                        unsigned int format,
3317                                        struct snd_pcm_substream *substream)
3318 {
3319         struct alc_spec *spec = codec->spec;
3320         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3321                                                 stream_tag, format, substream);
3322 }
3323
3324 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3325                                        struct hda_codec *codec,
3326                                        struct snd_pcm_substream *substream)
3327 {
3328         struct alc_spec *spec = codec->spec;
3329         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3330 }
3331
3332 /*
3333  * Digital out
3334  */
3335 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3336                                         struct hda_codec *codec,
3337                                         struct snd_pcm_substream *substream)
3338 {
3339         struct alc_spec *spec = codec->spec;
3340         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3341 }
3342
3343 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3344                                            struct hda_codec *codec,
3345                                            unsigned int stream_tag,
3346                                            unsigned int format,
3347                                            struct snd_pcm_substream *substream)
3348 {
3349         struct alc_spec *spec = codec->spec;
3350         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3351                                              stream_tag, format, substream);
3352 }
3353
3354 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3355                                            struct hda_codec *codec,
3356                                            struct snd_pcm_substream *substream)
3357 {
3358         struct alc_spec *spec = codec->spec;
3359         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3360 }
3361
3362 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3363                                          struct hda_codec *codec,
3364                                          struct snd_pcm_substream *substream)
3365 {
3366         struct alc_spec *spec = codec->spec;
3367         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3368 }
3369
3370 /*
3371  * Analog capture
3372  */
3373 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3374                                       struct hda_codec *codec,
3375                                       unsigned int stream_tag,
3376                                       unsigned int format,
3377                                       struct snd_pcm_substream *substream)
3378 {
3379         struct alc_spec *spec = codec->spec;
3380
3381         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3382                                    stream_tag, 0, format);
3383         return 0;
3384 }
3385
3386 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3387                                       struct hda_codec *codec,
3388                                       struct snd_pcm_substream *substream)
3389 {
3390         struct alc_spec *spec = codec->spec;
3391
3392         snd_hda_codec_cleanup_stream(codec,
3393                                      spec->adc_nids[substream->number + 1]);
3394         return 0;
3395 }
3396
3397
3398 /*
3399  */
3400 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3401         .substreams = 1,
3402         .channels_min = 2,
3403         .channels_max = 8,
3404         /* NID is set in alc_build_pcms */
3405         .ops = {
3406                 .open = alc880_playback_pcm_open,
3407                 .prepare = alc880_playback_pcm_prepare,
3408                 .cleanup = alc880_playback_pcm_cleanup
3409         },
3410 };
3411
3412 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3413         .substreams = 1,
3414         .channels_min = 2,
3415         .channels_max = 2,
3416         /* NID is set in alc_build_pcms */
3417 };
3418
3419 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3420         .substreams = 1,
3421         .channels_min = 2,
3422         .channels_max = 2,
3423         /* NID is set in alc_build_pcms */
3424 };
3425
3426 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3427         .substreams = 2, /* can be overridden */
3428         .channels_min = 2,
3429         .channels_max = 2,
3430         /* NID is set in alc_build_pcms */
3431         .ops = {
3432                 .prepare = alc880_alt_capture_pcm_prepare,
3433                 .cleanup = alc880_alt_capture_pcm_cleanup
3434         },
3435 };
3436
3437 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3438         .substreams = 1,
3439         .channels_min = 2,
3440         .channels_max = 2,
3441         /* NID is set in alc_build_pcms */
3442         .ops = {
3443                 .open = alc880_dig_playback_pcm_open,
3444                 .close = alc880_dig_playback_pcm_close,
3445                 .prepare = alc880_dig_playback_pcm_prepare,
3446                 .cleanup = alc880_dig_playback_pcm_cleanup
3447         },
3448 };
3449
3450 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3451         .substreams = 1,
3452         .channels_min = 2,
3453         .channels_max = 2,
3454         /* NID is set in alc_build_pcms */
3455 };
3456
3457 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3458 static struct hda_pcm_stream alc_pcm_null_stream = {
3459         .substreams = 0,
3460         .channels_min = 0,
3461         .channels_max = 0,
3462 };
3463
3464 static int alc_build_pcms(struct hda_codec *codec)
3465 {
3466         struct alc_spec *spec = codec->spec;
3467         struct hda_pcm *info = spec->pcm_rec;
3468         int i;
3469
3470         codec->num_pcms = 1;
3471         codec->pcm_info = info;
3472
3473         if (spec->no_analog)
3474                 goto skip_analog;
3475
3476         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3477                  "%s Analog", codec->chip_name);
3478         info->name = spec->stream_name_analog;
3479
3480         if (spec->stream_analog_playback) {
3481                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3482                         return -EINVAL;
3483                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3484                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3485         }
3486         if (spec->stream_analog_capture) {
3487                 if (snd_BUG_ON(!spec->adc_nids))
3488                         return -EINVAL;
3489                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3490                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3491         }
3492
3493         if (spec->channel_mode) {
3494                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3495                 for (i = 0; i < spec->num_channel_mode; i++) {
3496                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3497                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3498                         }
3499                 }
3500         }
3501
3502  skip_analog:
3503         /* SPDIF for stream index #1 */
3504         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3505                 snprintf(spec->stream_name_digital,
3506                          sizeof(spec->stream_name_digital),
3507                          "%s Digital", codec->chip_name);
3508                 codec->num_pcms = 2;
3509                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3510                 info = spec->pcm_rec + 1;
3511                 info->name = spec->stream_name_digital;
3512                 if (spec->dig_out_type)
3513                         info->pcm_type = spec->dig_out_type;
3514                 else
3515                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3516                 if (spec->multiout.dig_out_nid &&
3517                     spec->stream_digital_playback) {
3518                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3519                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3520                 }
3521                 if (spec->dig_in_nid &&
3522                     spec->stream_digital_capture) {
3523                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3524                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3525                 }
3526                 /* FIXME: do we need this for all Realtek codec models? */
3527                 codec->spdif_status_reset = 1;
3528         }
3529
3530         if (spec->no_analog)
3531                 return 0;
3532
3533         /* If the use of more than one ADC is requested for the current
3534          * model, configure a second analog capture-only PCM.
3535          */
3536         /* Additional Analaog capture for index #2 */
3537         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3538             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3539                 codec->num_pcms = 3;
3540                 info = spec->pcm_rec + 2;
3541                 info->name = spec->stream_name_analog;
3542                 if (spec->alt_dac_nid) {
3543                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3544                                 *spec->stream_analog_alt_playback;
3545                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3546                                 spec->alt_dac_nid;
3547                 } else {
3548                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3549                                 alc_pcm_null_stream;
3550                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3551                 }
3552                 if (spec->num_adc_nids > 1) {
3553                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3554                                 *spec->stream_analog_alt_capture;
3555                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3556                                 spec->adc_nids[1];
3557                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3558                                 spec->num_adc_nids - 1;
3559                 } else {
3560                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3561                                 alc_pcm_null_stream;
3562                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3563                 }
3564         }
3565
3566         return 0;
3567 }
3568
3569 static void alc_free_kctls(struct hda_codec *codec)
3570 {
3571         struct alc_spec *spec = codec->spec;
3572
3573         if (spec->kctls.list) {
3574                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3575                 int i;
3576                 for (i = 0; i < spec->kctls.used; i++)
3577                         kfree(kctl[i].name);
3578         }
3579         snd_array_free(&spec->kctls);
3580 }
3581
3582 static void alc_free(struct hda_codec *codec)
3583 {
3584         struct alc_spec *spec = codec->spec;
3585
3586         if (!spec)
3587                 return;
3588
3589         alc_free_kctls(codec);
3590         kfree(spec);
3591         snd_hda_detach_beep_device(codec);
3592 }
3593
3594 #ifdef SND_HDA_NEEDS_RESUME
3595 static int alc_resume(struct hda_codec *codec)
3596 {
3597         codec->patch_ops.init(codec);
3598         snd_hda_codec_resume_amp(codec);
3599         snd_hda_codec_resume_cache(codec);
3600         return 0;
3601 }
3602 #endif
3603
3604 /*
3605  */
3606 static struct hda_codec_ops alc_patch_ops = {
3607         .build_controls = alc_build_controls,
3608         .build_pcms = alc_build_pcms,
3609         .init = alc_init,
3610         .free = alc_free,
3611         .unsol_event = alc_unsol_event,
3612 #ifdef SND_HDA_NEEDS_RESUME
3613         .resume = alc_resume,
3614 #endif
3615 #ifdef CONFIG_SND_HDA_POWER_SAVE
3616         .check_power_status = alc_check_power_status,
3617 #endif
3618 };
3619
3620
3621 /*
3622  * Test configuration for debugging
3623  *
3624  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3625  * enum controls.
3626  */
3627 #ifdef CONFIG_SND_DEBUG
3628 static hda_nid_t alc880_test_dac_nids[4] = {
3629         0x02, 0x03, 0x04, 0x05
3630 };
3631
3632 static struct hda_input_mux alc880_test_capture_source = {
3633         .num_items = 7,
3634         .items = {
3635                 { "In-1", 0x0 },
3636                 { "In-2", 0x1 },
3637                 { "In-3", 0x2 },
3638                 { "In-4", 0x3 },
3639                 { "CD", 0x4 },
3640                 { "Front", 0x5 },
3641                 { "Surround", 0x6 },
3642         },
3643 };
3644
3645 static struct hda_channel_mode alc880_test_modes[4] = {
3646         { 2, NULL },
3647         { 4, NULL },
3648         { 6, NULL },
3649         { 8, NULL },
3650 };
3651
3652 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3653                                  struct snd_ctl_elem_info *uinfo)
3654 {
3655         static char *texts[] = {
3656                 "N/A", "Line Out", "HP Out",
3657                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3658         };
3659         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3660         uinfo->count = 1;
3661         uinfo->value.enumerated.items = 8;
3662         if (uinfo->value.enumerated.item >= 8)
3663                 uinfo->value.enumerated.item = 7;
3664         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3665         return 0;
3666 }
3667
3668 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3669                                 struct snd_ctl_elem_value *ucontrol)
3670 {
3671         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3672         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3673         unsigned int pin_ctl, item = 0;
3674
3675         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3676                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3677         if (pin_ctl & AC_PINCTL_OUT_EN) {
3678                 if (pin_ctl & AC_PINCTL_HP_EN)
3679                         item = 2;
3680                 else
3681                         item = 1;
3682         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3683                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3684                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3685                 case AC_PINCTL_VREF_50:  item = 4; break;
3686                 case AC_PINCTL_VREF_GRD: item = 5; break;
3687                 case AC_PINCTL_VREF_80:  item = 6; break;
3688                 case AC_PINCTL_VREF_100: item = 7; break;
3689                 }
3690         }
3691         ucontrol->value.enumerated.item[0] = item;
3692         return 0;
3693 }
3694
3695 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3696                                 struct snd_ctl_elem_value *ucontrol)
3697 {
3698         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3699         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3700         static unsigned int ctls[] = {
3701                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3702                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3703                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3704                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3705                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3706                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3707         };
3708         unsigned int old_ctl, new_ctl;
3709
3710         old_ctl = snd_hda_codec_read(codec, nid, 0,
3711                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3712         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3713         if (old_ctl != new_ctl) {
3714                 int val;
3715                 snd_hda_codec_write_cache(codec, nid, 0,
3716                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3717                                           new_ctl);
3718                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3719                         HDA_AMP_MUTE : 0;
3720                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3721                                          HDA_AMP_MUTE, val);
3722                 return 1;
3723         }
3724         return 0;
3725 }
3726
3727 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3728                                  struct snd_ctl_elem_info *uinfo)
3729 {
3730         static char *texts[] = {
3731                 "Front", "Surround", "CLFE", "Side"
3732         };
3733         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3734         uinfo->count = 1;
3735         uinfo->value.enumerated.items = 4;
3736         if (uinfo->value.enumerated.item >= 4)
3737                 uinfo->value.enumerated.item = 3;
3738         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3739         return 0;
3740 }
3741
3742 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3743                                 struct snd_ctl_elem_value *ucontrol)
3744 {
3745         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3746         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3747         unsigned int sel;
3748
3749         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3750         ucontrol->value.enumerated.item[0] = sel & 3;
3751         return 0;
3752 }
3753
3754 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3755                                 struct snd_ctl_elem_value *ucontrol)
3756 {
3757         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3758         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3759         unsigned int sel;
3760
3761         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3762         if (ucontrol->value.enumerated.item[0] != sel) {
3763                 sel = ucontrol->value.enumerated.item[0] & 3;
3764                 snd_hda_codec_write_cache(codec, nid, 0,
3765                                           AC_VERB_SET_CONNECT_SEL, sel);
3766                 return 1;
3767         }
3768         return 0;
3769 }
3770
3771 #define PIN_CTL_TEST(xname,nid) {                       \
3772                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3773                         .name = xname,                 \
3774                         .info = alc_test_pin_ctl_info, \
3775                         .get = alc_test_pin_ctl_get,   \
3776                         .put = alc_test_pin_ctl_put,   \
3777                         .private_value = nid           \
3778                         }
3779
3780 #define PIN_SRC_TEST(xname,nid) {                       \
3781                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3782                         .name = xname,                 \
3783                         .info = alc_test_pin_src_info, \
3784                         .get = alc_test_pin_src_get,   \
3785                         .put = alc_test_pin_src_put,   \
3786                         .private_value = nid           \
3787                         }
3788
3789 static struct snd_kcontrol_new alc880_test_mixer[] = {
3790         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3791         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3792         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3793         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3794         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3795         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3796         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3797         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3798         PIN_CTL_TEST("Front Pin Mode", 0x14),
3799         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3800         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3801         PIN_CTL_TEST("Side Pin Mode", 0x17),
3802         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3803         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3804         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3805         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3806         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3807         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3808         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3809         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3810         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3811         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3812         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3813         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3814         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3815         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3816         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3817         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3818         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3819         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3820         {
3821                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3822                 .name = "Channel Mode",
3823                 .info = alc_ch_mode_info,
3824                 .get = alc_ch_mode_get,
3825                 .put = alc_ch_mode_put,
3826         },
3827         { } /* end */
3828 };
3829
3830 static struct hda_verb alc880_test_init_verbs[] = {
3831         /* Unmute inputs of 0x0c - 0x0f */
3832         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3833         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3834         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3835         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3836         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3837         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3838         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3839         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3840         /* Vol output for 0x0c-0x0f */
3841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3842         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3843         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3844         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3845         /* Set output pins 0x14-0x17 */
3846         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3847         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3848         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3849         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3850         /* Unmute output pins 0x14-0x17 */
3851         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3852         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3853         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3854         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3855         /* Set input pins 0x18-0x1c */
3856         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3857         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3858         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3859         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3860         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3861         /* Mute input pins 0x18-0x1b */
3862         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3863         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3864         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3865         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3866         /* ADC set up */
3867         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3868         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3869         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3870         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3871         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3872         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3873         /* Analog input/passthru */
3874         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3875         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3876         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3877         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3878         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3879         { }
3880 };
3881 #endif
3882
3883 /*
3884  */
3885
3886 static const char *alc880_models[ALC880_MODEL_LAST] = {
3887         [ALC880_3ST]            = "3stack",
3888         [ALC880_TCL_S700]       = "tcl",
3889         [ALC880_3ST_DIG]        = "3stack-digout",
3890         [ALC880_CLEVO]          = "clevo",
3891         [ALC880_5ST]            = "5stack",
3892         [ALC880_5ST_DIG]        = "5stack-digout",
3893         [ALC880_W810]           = "w810",
3894         [ALC880_Z71V]           = "z71v",
3895         [ALC880_6ST]            = "6stack",
3896         [ALC880_6ST_DIG]        = "6stack-digout",
3897         [ALC880_ASUS]           = "asus",
3898         [ALC880_ASUS_W1V]       = "asus-w1v",
3899         [ALC880_ASUS_DIG]       = "asus-dig",
3900         [ALC880_ASUS_DIG2]      = "asus-dig2",
3901         [ALC880_UNIWILL_DIG]    = "uniwill",
3902         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3903         [ALC880_FUJITSU]        = "fujitsu",
3904         [ALC880_F1734]          = "F1734",
3905         [ALC880_LG]             = "lg",
3906         [ALC880_LG_LW]          = "lg-lw",
3907         [ALC880_MEDION_RIM]     = "medion",
3908 #ifdef CONFIG_SND_DEBUG
3909         [ALC880_TEST]           = "test",
3910 #endif
3911         [ALC880_AUTO]           = "auto",
3912 };
3913
3914 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3915         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3916         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3917         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3918         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3919         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3920         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3921         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3922         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3923         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3924         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3925         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3926         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3927         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3928         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3929         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3930         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3931         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3932         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3933         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3934         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3935         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3936         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3937         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3938         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3939         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3940         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3941         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3942         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3943         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3944         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3945         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3946         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3947         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3948         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3949         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3950         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3951         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3952         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3953         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3954         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3955         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3956         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3957         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3958         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3959         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3960         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3961         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3962         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3963         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3964         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3965         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3966         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3967         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3968         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3969         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3970         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3971         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3972         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3973         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3974         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3975         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3976         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3977         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3978         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3979         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3980         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3981         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3982         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3983         /* default Intel */
3984         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3985         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3986         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3987         {}
3988 };
3989
3990 /*
3991  * ALC880 codec presets
3992  */
3993 static struct alc_config_preset alc880_presets[] = {
3994         [ALC880_3ST] = {
3995                 .mixers = { alc880_three_stack_mixer },
3996                 .init_verbs = { alc880_volume_init_verbs,
3997                                 alc880_pin_3stack_init_verbs },
3998                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
3999                 .dac_nids = alc880_dac_nids,
4000                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4001                 .channel_mode = alc880_threestack_modes,
4002                 .need_dac_fix = 1,
4003                 .input_mux = &alc880_capture_source,
4004         },
4005         [ALC880_3ST_DIG] = {
4006                 .mixers = { alc880_three_stack_mixer },
4007                 .init_verbs = { alc880_volume_init_verbs,
4008                                 alc880_pin_3stack_init_verbs },
4009                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4010                 .dac_nids = alc880_dac_nids,
4011                 .dig_out_nid = ALC880_DIGOUT_NID,
4012                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4013                 .channel_mode = alc880_threestack_modes,
4014                 .need_dac_fix = 1,
4015                 .input_mux = &alc880_capture_source,
4016         },
4017         [ALC880_TCL_S700] = {
4018                 .mixers = { alc880_tcl_s700_mixer },
4019                 .init_verbs = { alc880_volume_init_verbs,
4020                                 alc880_pin_tcl_S700_init_verbs,
4021                                 alc880_gpio2_init_verbs },
4022                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4023                 .dac_nids = alc880_dac_nids,
4024                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4025                 .num_adc_nids = 1, /* single ADC */
4026                 .hp_nid = 0x03,
4027                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4028                 .channel_mode = alc880_2_jack_modes,
4029                 .input_mux = &alc880_capture_source,
4030         },
4031         [ALC880_5ST] = {
4032                 .mixers = { alc880_three_stack_mixer,
4033                             alc880_five_stack_mixer},
4034                 .init_verbs = { alc880_volume_init_verbs,
4035                                 alc880_pin_5stack_init_verbs },
4036                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4037                 .dac_nids = alc880_dac_nids,
4038                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4039                 .channel_mode = alc880_fivestack_modes,
4040                 .input_mux = &alc880_capture_source,
4041         },
4042         [ALC880_5ST_DIG] = {
4043                 .mixers = { alc880_three_stack_mixer,
4044                             alc880_five_stack_mixer },
4045                 .init_verbs = { alc880_volume_init_verbs,
4046                                 alc880_pin_5stack_init_verbs },
4047                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4048                 .dac_nids = alc880_dac_nids,
4049                 .dig_out_nid = ALC880_DIGOUT_NID,
4050                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4051                 .channel_mode = alc880_fivestack_modes,
4052                 .input_mux = &alc880_capture_source,
4053         },
4054         [ALC880_6ST] = {
4055                 .mixers = { alc880_six_stack_mixer },
4056                 .init_verbs = { alc880_volume_init_verbs,
4057                                 alc880_pin_6stack_init_verbs },
4058                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4059                 .dac_nids = alc880_6st_dac_nids,
4060                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4061                 .channel_mode = alc880_sixstack_modes,
4062                 .input_mux = &alc880_6stack_capture_source,
4063         },
4064         [ALC880_6ST_DIG] = {
4065                 .mixers = { alc880_six_stack_mixer },
4066                 .init_verbs = { alc880_volume_init_verbs,
4067                                 alc880_pin_6stack_init_verbs },
4068                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4069                 .dac_nids = alc880_6st_dac_nids,
4070                 .dig_out_nid = ALC880_DIGOUT_NID,
4071                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4072                 .channel_mode = alc880_sixstack_modes,
4073                 .input_mux = &alc880_6stack_capture_source,
4074         },
4075         [ALC880_W810] = {
4076                 .mixers = { alc880_w810_base_mixer },
4077                 .init_verbs = { alc880_volume_init_verbs,
4078                                 alc880_pin_w810_init_verbs,
4079                                 alc880_gpio2_init_verbs },
4080                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4081                 .dac_nids = alc880_w810_dac_nids,
4082                 .dig_out_nid = ALC880_DIGOUT_NID,
4083                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4084                 .channel_mode = alc880_w810_modes,
4085                 .input_mux = &alc880_capture_source,
4086         },
4087         [ALC880_Z71V] = {
4088                 .mixers = { alc880_z71v_mixer },
4089                 .init_verbs = { alc880_volume_init_verbs,
4090                                 alc880_pin_z71v_init_verbs },
4091                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4092                 .dac_nids = alc880_z71v_dac_nids,
4093                 .dig_out_nid = ALC880_DIGOUT_NID,
4094                 .hp_nid = 0x03,
4095                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4096                 .channel_mode = alc880_2_jack_modes,
4097                 .input_mux = &alc880_capture_source,
4098         },
4099         [ALC880_F1734] = {
4100                 .mixers = { alc880_f1734_mixer },
4101                 .init_verbs = { alc880_volume_init_verbs,
4102                                 alc880_pin_f1734_init_verbs },
4103                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4104                 .dac_nids = alc880_f1734_dac_nids,
4105                 .hp_nid = 0x02,
4106                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4107                 .channel_mode = alc880_2_jack_modes,
4108                 .input_mux = &alc880_f1734_capture_source,
4109                 .unsol_event = alc880_uniwill_p53_unsol_event,
4110                 .init_hook = alc880_uniwill_p53_init_hook,
4111         },
4112         [ALC880_ASUS] = {
4113                 .mixers = { alc880_asus_mixer },
4114                 .init_verbs = { alc880_volume_init_verbs,
4115                                 alc880_pin_asus_init_verbs,
4116                                 alc880_gpio1_init_verbs },
4117                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4118                 .dac_nids = alc880_asus_dac_nids,
4119                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4120                 .channel_mode = alc880_asus_modes,
4121                 .need_dac_fix = 1,
4122                 .input_mux = &alc880_capture_source,
4123         },
4124         [ALC880_ASUS_DIG] = {
4125                 .mixers = { alc880_asus_mixer },
4126                 .init_verbs = { alc880_volume_init_verbs,
4127                                 alc880_pin_asus_init_verbs,
4128                                 alc880_gpio1_init_verbs },
4129                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4130                 .dac_nids = alc880_asus_dac_nids,
4131                 .dig_out_nid = ALC880_DIGOUT_NID,
4132                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4133                 .channel_mode = alc880_asus_modes,
4134                 .need_dac_fix = 1,
4135                 .input_mux = &alc880_capture_source,
4136         },
4137         [ALC880_ASUS_DIG2] = {
4138                 .mixers = { alc880_asus_mixer },
4139                 .init_verbs = { alc880_volume_init_verbs,
4140                                 alc880_pin_asus_init_verbs,
4141                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4142                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4143                 .dac_nids = alc880_asus_dac_nids,
4144                 .dig_out_nid = ALC880_DIGOUT_NID,
4145                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4146                 .channel_mode = alc880_asus_modes,
4147                 .need_dac_fix = 1,
4148                 .input_mux = &alc880_capture_source,
4149         },
4150         [ALC880_ASUS_W1V] = {
4151                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4152                 .init_verbs = { alc880_volume_init_verbs,
4153                                 alc880_pin_asus_init_verbs,
4154                                 alc880_gpio1_init_verbs },
4155                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4156                 .dac_nids = alc880_asus_dac_nids,
4157                 .dig_out_nid = ALC880_DIGOUT_NID,
4158                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4159                 .channel_mode = alc880_asus_modes,
4160                 .need_dac_fix = 1,
4161                 .input_mux = &alc880_capture_source,
4162         },
4163         [ALC880_UNIWILL_DIG] = {
4164                 .mixers = { alc880_asus_mixer },
4165                 .init_verbs = { alc880_volume_init_verbs,
4166                                 alc880_pin_asus_init_verbs },
4167                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4168                 .dac_nids = alc880_asus_dac_nids,
4169                 .dig_out_nid = ALC880_DIGOUT_NID,
4170                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4171                 .channel_mode = alc880_asus_modes,
4172                 .need_dac_fix = 1,
4173                 .input_mux = &alc880_capture_source,
4174         },
4175         [ALC880_UNIWILL] = {
4176                 .mixers = { alc880_uniwill_mixer },
4177                 .init_verbs = { alc880_volume_init_verbs,
4178                                 alc880_uniwill_init_verbs },
4179                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4180                 .dac_nids = alc880_asus_dac_nids,
4181                 .dig_out_nid = ALC880_DIGOUT_NID,
4182                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4183                 .channel_mode = alc880_threestack_modes,
4184                 .need_dac_fix = 1,
4185                 .input_mux = &alc880_capture_source,
4186                 .unsol_event = alc880_uniwill_unsol_event,
4187                 .init_hook = alc880_uniwill_init_hook,
4188         },
4189         [ALC880_UNIWILL_P53] = {
4190                 .mixers = { alc880_uniwill_p53_mixer },
4191                 .init_verbs = { alc880_volume_init_verbs,
4192                                 alc880_uniwill_p53_init_verbs },
4193                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4194                 .dac_nids = alc880_asus_dac_nids,
4195                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4196                 .channel_mode = alc880_threestack_modes,
4197                 .input_mux = &alc880_capture_source,
4198                 .unsol_event = alc880_uniwill_p53_unsol_event,
4199                 .init_hook = alc880_uniwill_p53_init_hook,
4200         },
4201         [ALC880_FUJITSU] = {
4202                 .mixers = { alc880_fujitsu_mixer },
4203                 .init_verbs = { alc880_volume_init_verbs,
4204                                 alc880_uniwill_p53_init_verbs,
4205                                 alc880_beep_init_verbs },
4206                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4207                 .dac_nids = alc880_dac_nids,
4208                 .dig_out_nid = ALC880_DIGOUT_NID,
4209                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4210                 .channel_mode = alc880_2_jack_modes,
4211                 .input_mux = &alc880_capture_source,
4212                 .unsol_event = alc880_uniwill_p53_unsol_event,
4213                 .init_hook = alc880_uniwill_p53_init_hook,
4214         },
4215         [ALC880_CLEVO] = {
4216                 .mixers = { alc880_three_stack_mixer },
4217                 .init_verbs = { alc880_volume_init_verbs,
4218                                 alc880_pin_clevo_init_verbs },
4219                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4220                 .dac_nids = alc880_dac_nids,
4221                 .hp_nid = 0x03,
4222                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4223                 .channel_mode = alc880_threestack_modes,
4224                 .need_dac_fix = 1,
4225                 .input_mux = &alc880_capture_source,
4226         },
4227         [ALC880_LG] = {
4228                 .mixers = { alc880_lg_mixer },
4229                 .init_verbs = { alc880_volume_init_verbs,
4230                                 alc880_lg_init_verbs },
4231                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4232                 .dac_nids = alc880_lg_dac_nids,
4233                 .dig_out_nid = ALC880_DIGOUT_NID,
4234                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4235                 .channel_mode = alc880_lg_ch_modes,
4236                 .need_dac_fix = 1,
4237                 .input_mux = &alc880_lg_capture_source,
4238                 .unsol_event = alc_automute_amp_unsol_event,
4239                 .init_hook = alc880_lg_init_hook,
4240 #ifdef CONFIG_SND_HDA_POWER_SAVE
4241                 .loopbacks = alc880_lg_loopbacks,
4242 #endif
4243         },
4244         [ALC880_LG_LW] = {
4245                 .mixers = { alc880_lg_lw_mixer },
4246                 .init_verbs = { alc880_volume_init_verbs,
4247                                 alc880_lg_lw_init_verbs },
4248                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4249                 .dac_nids = alc880_dac_nids,
4250                 .dig_out_nid = ALC880_DIGOUT_NID,
4251                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4252                 .channel_mode = alc880_lg_lw_modes,
4253                 .input_mux = &alc880_lg_lw_capture_source,
4254                 .unsol_event = alc_automute_amp_unsol_event,
4255                 .init_hook = alc880_lg_lw_init_hook,
4256         },
4257         [ALC880_MEDION_RIM] = {
4258                 .mixers = { alc880_medion_rim_mixer },
4259                 .init_verbs = { alc880_volume_init_verbs,
4260                                 alc880_medion_rim_init_verbs,
4261                                 alc_gpio2_init_verbs },
4262                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4263                 .dac_nids = alc880_dac_nids,
4264                 .dig_out_nid = ALC880_DIGOUT_NID,
4265                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4266                 .channel_mode = alc880_2_jack_modes,
4267                 .input_mux = &alc880_medion_rim_capture_source,
4268                 .unsol_event = alc880_medion_rim_unsol_event,
4269                 .init_hook = alc880_medion_rim_init_hook,
4270         },
4271 #ifdef CONFIG_SND_DEBUG
4272         [ALC880_TEST] = {
4273                 .mixers = { alc880_test_mixer },
4274                 .init_verbs = { alc880_test_init_verbs },
4275                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4276                 .dac_nids = alc880_test_dac_nids,
4277                 .dig_out_nid = ALC880_DIGOUT_NID,
4278                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4279                 .channel_mode = alc880_test_modes,
4280                 .input_mux = &alc880_test_capture_source,
4281         },
4282 #endif
4283 };
4284
4285 /*
4286  * Automatic parse of I/O pins from the BIOS configuration
4287  */
4288
4289 enum {
4290         ALC_CTL_WIDGET_VOL,
4291         ALC_CTL_WIDGET_MUTE,
4292         ALC_CTL_BIND_MUTE,
4293 };
4294 static struct snd_kcontrol_new alc880_control_templates[] = {
4295         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4296         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4297         HDA_BIND_MUTE(NULL, 0, 0, 0),
4298 };
4299
4300 /* add dynamic controls */
4301 static int add_control(struct alc_spec *spec, int type, const char *name,
4302                        unsigned long val)
4303 {
4304         struct snd_kcontrol_new *knew;
4305
4306         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4307         knew = snd_array_new(&spec->kctls);
4308         if (!knew)
4309                 return -ENOMEM;
4310         *knew = alc880_control_templates[type];
4311         knew->name = kstrdup(name, GFP_KERNEL);
4312         if (!knew->name)
4313                 return -ENOMEM;
4314         knew->private_value = val;
4315         return 0;
4316 }
4317
4318 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4319 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4320 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4321 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4322 #define alc880_is_input_pin(nid)        ((nid) >= 0x18)
4323 #define alc880_input_pin_idx(nid)       ((nid) - 0x18)
4324 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4325 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4326 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4327 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4328 #define ALC880_PIN_CD_NID               0x1c
4329
4330 /* fill in the dac_nids table from the parsed pin configuration */
4331 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4332                                      const struct auto_pin_cfg *cfg)
4333 {
4334         hda_nid_t nid;
4335         int assigned[4];
4336         int i, j;
4337
4338         memset(assigned, 0, sizeof(assigned));
4339         spec->multiout.dac_nids = spec->private_dac_nids;
4340
4341         /* check the pins hardwired to audio widget */
4342         for (i = 0; i < cfg->line_outs; i++) {
4343                 nid = cfg->line_out_pins[i];
4344                 if (alc880_is_fixed_pin(nid)) {
4345                         int idx = alc880_fixed_pin_idx(nid);
4346                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4347                         assigned[idx] = 1;
4348                 }
4349         }
4350         /* left pins can be connect to any audio widget */
4351         for (i = 0; i < cfg->line_outs; i++) {
4352                 nid = cfg->line_out_pins[i];
4353                 if (alc880_is_fixed_pin(nid))
4354                         continue;
4355                 /* search for an empty channel */
4356                 for (j = 0; j < cfg->line_outs; j++) {
4357                         if (!assigned[j]) {
4358                                 spec->multiout.dac_nids[i] =
4359                                         alc880_idx_to_dac(j);
4360                                 assigned[j] = 1;
4361                                 break;
4362                         }
4363                 }
4364         }
4365         spec->multiout.num_dacs = cfg->line_outs;
4366         return 0;
4367 }
4368
4369 /* add playback controls from the parsed DAC table */
4370 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4371                                              const struct auto_pin_cfg *cfg)
4372 {
4373         char name[32];
4374         static const char *chname[4] = {
4375                 "Front", "Surround", NULL /*CLFE*/, "Side"
4376         };
4377         hda_nid_t nid;
4378         int i, err;
4379
4380         for (i = 0; i < cfg->line_outs; i++) {
4381                 if (!spec->multiout.dac_nids[i])
4382                         continue;
4383                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4384                 if (i == 2) {
4385                         /* Center/LFE */
4386                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4387                                           "Center Playback Volume",
4388                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4389                                                               HDA_OUTPUT));
4390                         if (err < 0)
4391                                 return err;
4392                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4393                                           "LFE Playback Volume",
4394                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4395                                                               HDA_OUTPUT));
4396                         if (err < 0)
4397                                 return err;
4398                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4399                                           "Center Playback Switch",
4400                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4401                                                               HDA_INPUT));
4402                         if (err < 0)
4403                                 return err;
4404                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4405                                           "LFE Playback Switch",
4406                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4407                                                               HDA_INPUT));
4408                         if (err < 0)
4409                                 return err;
4410                 } else {
4411                         sprintf(name, "%s Playback Volume", chname[i]);
4412                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4413                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4414                                                               HDA_OUTPUT));
4415                         if (err < 0)
4416                                 return err;
4417                         sprintf(name, "%s Playback Switch", chname[i]);
4418                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4419                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4420                                                               HDA_INPUT));
4421                         if (err < 0)
4422                                 return err;
4423                 }
4424         }
4425         return 0;
4426 }
4427
4428 /* add playback controls for speaker and HP outputs */
4429 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4430                                         const char *pfx)
4431 {
4432         hda_nid_t nid;
4433         int err;
4434         char name[32];
4435
4436         if (!pin)
4437                 return 0;
4438
4439         if (alc880_is_fixed_pin(pin)) {
4440                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4441                 /* specify the DAC as the extra output */
4442                 if (!spec->multiout.hp_nid)
4443                         spec->multiout.hp_nid = nid;
4444                 else
4445                         spec->multiout.extra_out_nid[0] = nid;
4446                 /* control HP volume/switch on the output mixer amp */
4447                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4448                 sprintf(name, "%s Playback Volume", pfx);
4449                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4450                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4451                 if (err < 0)
4452                         return err;
4453                 sprintf(name, "%s Playback Switch", pfx);
4454                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4455                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4456                 if (err < 0)
4457                         return err;
4458         } else if (alc880_is_multi_pin(pin)) {
4459                 /* set manual connection */
4460                 /* we have only a switch on HP-out PIN */
4461                 sprintf(name, "%s Playback Switch", pfx);
4462                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4463                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4464                 if (err < 0)
4465                         return err;
4466         }
4467         return 0;
4468 }
4469
4470 /* create input playback/capture controls for the given pin */
4471 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4472                             const char *ctlname,
4473                             int idx, hda_nid_t mix_nid)
4474 {
4475         char name[32];
4476         int err;
4477
4478         sprintf(name, "%s Playback Volume", ctlname);
4479         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4480                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4481         if (err < 0)
4482                 return err;
4483         sprintf(name, "%s Playback Switch", ctlname);
4484         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4485                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4486         if (err < 0)
4487                 return err;
4488         return 0;
4489 }
4490
4491 /* create playback/capture controls for input pins */
4492 static int alc880_auto_create_analog_input_ctls(struct alc_spec *spec,
4493                                                 const struct auto_pin_cfg *cfg)
4494 {
4495         struct hda_input_mux *imux = &spec->private_imux[0];
4496         int i, err, idx;
4497
4498         for (i = 0; i < AUTO_PIN_LAST; i++) {
4499                 if (alc880_is_input_pin(cfg->input_pins[i])) {
4500                         idx = alc880_input_pin_idx(cfg->input_pins[i]);
4501                         err = new_analog_input(spec, cfg->input_pins[i],
4502                                                auto_pin_cfg_labels[i],
4503                                                idx, 0x0b);
4504                         if (err < 0)
4505                                 return err;
4506                         imux->items[imux->num_items].label =
4507                                 auto_pin_cfg_labels[i];
4508                         imux->items[imux->num_items].index =
4509                                 alc880_input_pin_idx(cfg->input_pins[i]);
4510                         imux->num_items++;
4511                 }
4512         }
4513         return 0;
4514 }
4515
4516 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4517                                unsigned int pin_type)
4518 {
4519         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4520                             pin_type);
4521         /* unmute pin */
4522         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4523                             AMP_OUT_UNMUTE);
4524 }
4525
4526 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4527                                               hda_nid_t nid, int pin_type,
4528                                               int dac_idx)
4529 {
4530         alc_set_pin_output(codec, nid, pin_type);
4531         /* need the manual connection? */
4532         if (alc880_is_multi_pin(nid)) {
4533                 struct alc_spec *spec = codec->spec;
4534                 int idx = alc880_multi_pin_idx(nid);
4535                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4536                                     AC_VERB_SET_CONNECT_SEL,
4537                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4538         }
4539 }
4540
4541 static int get_pin_type(int line_out_type)
4542 {
4543         if (line_out_type == AUTO_PIN_HP_OUT)
4544                 return PIN_HP;
4545         else
4546                 return PIN_OUT;
4547 }
4548
4549 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4550 {
4551         struct alc_spec *spec = codec->spec;
4552         int i;
4553
4554         for (i = 0; i < spec->autocfg.line_outs; i++) {
4555                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4556                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4557                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4558         }
4559 }
4560
4561 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4562 {
4563         struct alc_spec *spec = codec->spec;
4564         hda_nid_t pin;
4565
4566         pin = spec->autocfg.speaker_pins[0];
4567         if (pin) /* connect to front */
4568                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4569         pin = spec->autocfg.hp_pins[0];
4570         if (pin) /* connect to front */
4571                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4572 }
4573
4574 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4575 {
4576         struct alc_spec *spec = codec->spec;
4577         int i;
4578
4579         for (i = 0; i < AUTO_PIN_LAST; i++) {
4580                 hda_nid_t nid = spec->autocfg.input_pins[i];
4581                 if (alc880_is_input_pin(nid)) {
4582                         alc_set_input_pin(codec, nid, i);
4583                         if (nid != ALC880_PIN_CD_NID &&
4584                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4585                                 snd_hda_codec_write(codec, nid, 0,
4586                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4587                                                     AMP_OUT_MUTE);
4588                 }
4589         }
4590 }
4591
4592 /* parse the BIOS configuration and set up the alc_spec */
4593 /* return 1 if successful, 0 if the proper config is not found,
4594  * or a negative error code
4595  */
4596 static int alc880_parse_auto_config(struct hda_codec *codec)
4597 {
4598         struct alc_spec *spec = codec->spec;
4599         int i, err;
4600         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4601
4602         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4603                                            alc880_ignore);
4604         if (err < 0)
4605                 return err;
4606         if (!spec->autocfg.line_outs)
4607                 return 0; /* can't find valid BIOS pin config */
4608
4609         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4610         if (err < 0)
4611                 return err;
4612         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4613         if (err < 0)
4614                 return err;
4615         err = alc880_auto_create_extra_out(spec,
4616                                            spec->autocfg.speaker_pins[0],
4617                                            "Speaker");
4618         if (err < 0)
4619                 return err;
4620         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4621                                            "Headphone");
4622         if (err < 0)
4623                 return err;
4624         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
4625         if (err < 0)
4626                 return err;
4627
4628         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4629
4630         /* check multiple SPDIF-out (for recent codecs) */
4631         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4632                 hda_nid_t dig_nid;
4633                 err = snd_hda_get_connections(codec,
4634                                               spec->autocfg.dig_out_pins[i],
4635                                               &dig_nid, 1);
4636                 if (err < 0)
4637                         continue;
4638                 if (!i)
4639                         spec->multiout.dig_out_nid = dig_nid;
4640                 else {
4641                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4642                         spec->slave_dig_outs[i - 1] = dig_nid;
4643                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4644                                 break;
4645                 }
4646         }
4647         if (spec->autocfg.dig_in_pin)
4648                 spec->dig_in_nid = ALC880_DIGIN_NID;
4649
4650         if (spec->kctls.list)
4651                 add_mixer(spec, spec->kctls.list);
4652
4653         add_verb(spec, alc880_volume_init_verbs);
4654
4655         spec->num_mux_defs = 1;
4656         spec->input_mux = &spec->private_imux[0];
4657
4658         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4659
4660         return 1;
4661 }
4662
4663 /* additional initialization for auto-configuration model */
4664 static void alc880_auto_init(struct hda_codec *codec)
4665 {
4666         struct alc_spec *spec = codec->spec;
4667         alc880_auto_init_multi_out(codec);
4668         alc880_auto_init_extra_out(codec);
4669         alc880_auto_init_analog_input(codec);
4670         if (spec->unsol_event)
4671                 alc_inithook(codec);
4672 }
4673
4674 static void set_capture_mixer(struct alc_spec *spec)
4675 {
4676         static struct snd_kcontrol_new *caps[2][3] = {
4677                 { alc_capture_mixer_nosrc1,
4678                   alc_capture_mixer_nosrc2,
4679                   alc_capture_mixer_nosrc3 },
4680                 { alc_capture_mixer1,
4681                   alc_capture_mixer2,
4682                   alc_capture_mixer3 },
4683         };
4684         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4685                 int mux;
4686                 if (spec->auto_mic) {
4687                         mux = 0;
4688                         spec->num_adc_nids = 1; /* support only one ADC */
4689                 } else if (spec->input_mux && spec->input_mux->num_items > 1)
4690                         mux = 1;
4691                 else
4692                         mux = 0;
4693                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4694         }
4695 }
4696
4697 #define set_beep_amp(spec, nid, idx, dir) \
4698         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4699
4700 /*
4701  * OK, here we have finally the patch for ALC880
4702  */
4703
4704 static int patch_alc880(struct hda_codec *codec)
4705 {
4706         struct alc_spec *spec;
4707         int board_config;
4708         int err;
4709
4710         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4711         if (spec == NULL)
4712                 return -ENOMEM;
4713
4714         codec->spec = spec;
4715
4716         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4717                                                   alc880_models,
4718                                                   alc880_cfg_tbl);
4719         if (board_config < 0) {
4720                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4721                        codec->chip_name);
4722                 board_config = ALC880_AUTO;
4723         }
4724
4725         if (board_config == ALC880_AUTO) {
4726                 /* automatic parse from the BIOS config */
4727                 err = alc880_parse_auto_config(codec);
4728                 if (err < 0) {
4729                         alc_free(codec);
4730                         return err;
4731                 } else if (!err) {
4732                         printk(KERN_INFO
4733                                "hda_codec: Cannot set up configuration "
4734                                "from BIOS.  Using 3-stack mode...\n");
4735                         board_config = ALC880_3ST;
4736                 }
4737         }
4738
4739         err = snd_hda_attach_beep_device(codec, 0x1);
4740         if (err < 0) {
4741                 alc_free(codec);
4742                 return err;
4743         }
4744
4745         if (board_config != ALC880_AUTO)
4746                 setup_preset(spec, &alc880_presets[board_config]);
4747
4748         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4749         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4750         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4751
4752         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4753         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4754
4755         if (!spec->adc_nids && spec->input_mux) {
4756                 /* check whether NID 0x07 is valid */
4757                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4758                 /* get type */
4759                 wcap = get_wcaps_type(wcap);
4760                 if (wcap != AC_WID_AUD_IN) {
4761                         spec->adc_nids = alc880_adc_nids_alt;
4762                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4763                 } else {
4764                         spec->adc_nids = alc880_adc_nids;
4765                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4766                 }
4767         }
4768         set_capture_mixer(spec);
4769         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4770
4771         spec->vmaster_nid = 0x0c;
4772
4773         codec->patch_ops = alc_patch_ops;
4774         if (board_config == ALC880_AUTO)
4775                 spec->init_hook = alc880_auto_init;
4776 #ifdef CONFIG_SND_HDA_POWER_SAVE
4777         if (!spec->loopback.amplist)
4778                 spec->loopback.amplist = alc880_loopbacks;
4779 #endif
4780         codec->proc_widget_hook = print_realtek_coef;
4781
4782         return 0;
4783 }
4784
4785
4786 /*
4787  * ALC260 support
4788  */
4789
4790 static hda_nid_t alc260_dac_nids[1] = {
4791         /* front */
4792         0x02,
4793 };
4794
4795 static hda_nid_t alc260_adc_nids[1] = {
4796         /* ADC0 */
4797         0x04,
4798 };
4799
4800 static hda_nid_t alc260_adc_nids_alt[1] = {
4801         /* ADC1 */
4802         0x05,
4803 };
4804
4805 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4806  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4807  */
4808 static hda_nid_t alc260_dual_adc_nids[2] = {
4809         /* ADC0, ADC1 */
4810         0x04, 0x05
4811 };
4812
4813 #define ALC260_DIGOUT_NID       0x03
4814 #define ALC260_DIGIN_NID        0x06
4815
4816 static struct hda_input_mux alc260_capture_source = {
4817         .num_items = 4,
4818         .items = {
4819                 { "Mic", 0x0 },
4820                 { "Front Mic", 0x1 },
4821                 { "Line", 0x2 },
4822                 { "CD", 0x4 },
4823         },
4824 };
4825
4826 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4827  * headphone jack and the internal CD lines since these are the only pins at
4828  * which audio can appear.  For flexibility, also allow the option of
4829  * recording the mixer output on the second ADC (ADC0 doesn't have a
4830  * connection to the mixer output).
4831  */
4832 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4833         {
4834                 .num_items = 3,
4835                 .items = {
4836                         { "Mic/Line", 0x0 },
4837                         { "CD", 0x4 },
4838                         { "Headphone", 0x2 },
4839                 },
4840         },
4841         {
4842                 .num_items = 4,
4843                 .items = {
4844                         { "Mic/Line", 0x0 },
4845                         { "CD", 0x4 },
4846                         { "Headphone", 0x2 },
4847                         { "Mixer", 0x5 },
4848                 },
4849         },
4850
4851 };
4852
4853 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4854  * the Fujitsu S702x, but jacks are marked differently.
4855  */
4856 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4857         {
4858                 .num_items = 4,
4859                 .items = {
4860                         { "Mic", 0x0 },
4861                         { "Line", 0x2 },
4862                         { "CD", 0x4 },
4863                         { "Headphone", 0x5 },
4864                 },
4865         },
4866         {
4867                 .num_items = 5,
4868                 .items = {
4869                         { "Mic", 0x0 },
4870                         { "Line", 0x2 },
4871                         { "CD", 0x4 },
4872                         { "Headphone", 0x6 },
4873                         { "Mixer", 0x5 },
4874                 },
4875         },
4876 };
4877
4878 /* Maxdata Favorit 100XS */
4879 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4880         {
4881                 .num_items = 2,
4882                 .items = {
4883                         { "Line/Mic", 0x0 },
4884                         { "CD", 0x4 },
4885                 },
4886         },
4887         {
4888                 .num_items = 3,
4889                 .items = {
4890                         { "Line/Mic", 0x0 },
4891                         { "CD", 0x4 },
4892                         { "Mixer", 0x5 },
4893                 },
4894         },
4895 };
4896
4897 /*
4898  * This is just place-holder, so there's something for alc_build_pcms to look
4899  * at when it calculates the maximum number of channels. ALC260 has no mixer
4900  * element which allows changing the channel mode, so the verb list is
4901  * never used.
4902  */
4903 static struct hda_channel_mode alc260_modes[1] = {
4904         { 2, NULL },
4905 };
4906
4907
4908 /* Mixer combinations
4909  *
4910  * basic: base_output + input + pc_beep + capture
4911  * HP: base_output + input + capture_alt
4912  * HP_3013: hp_3013 + input + capture
4913  * fujitsu: fujitsu + capture
4914  * acer: acer + capture
4915  */
4916
4917 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4918         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4919         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4920         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4921         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4922         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
4923         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
4924         { } /* end */
4925 };
4926
4927 static struct snd_kcontrol_new alc260_input_mixer[] = {
4928         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
4929         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
4930         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
4931         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
4932         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
4933         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
4934         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
4935         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
4936         { } /* end */
4937 };
4938
4939 /* update HP, line and mono out pins according to the master switch */
4940 static void alc260_hp_master_update(struct hda_codec *codec,
4941                                     hda_nid_t hp, hda_nid_t line,
4942                                     hda_nid_t mono)
4943 {
4944         struct alc_spec *spec = codec->spec;
4945         unsigned int val = spec->master_sw ? PIN_HP : 0;
4946         /* change HP and line-out pins */
4947         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4948                             val);
4949         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4950                             val);
4951         /* mono (speaker) depending on the HP jack sense */
4952         val = (val && !spec->jack_present) ? PIN_OUT : 0;
4953         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4954                             val);
4955 }
4956
4957 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
4958                                    struct snd_ctl_elem_value *ucontrol)
4959 {
4960         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4961         struct alc_spec *spec = codec->spec;
4962         *ucontrol->value.integer.value = spec->master_sw;
4963         return 0;
4964 }
4965
4966 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
4967                                    struct snd_ctl_elem_value *ucontrol)
4968 {
4969         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4970         struct alc_spec *spec = codec->spec;
4971         int val = !!*ucontrol->value.integer.value;
4972         hda_nid_t hp, line, mono;
4973
4974         if (val == spec->master_sw)
4975                 return 0;
4976         spec->master_sw = val;
4977         hp = (kcontrol->private_value >> 16) & 0xff;
4978         line = (kcontrol->private_value >> 8) & 0xff;
4979         mono = kcontrol->private_value & 0xff;
4980         alc260_hp_master_update(codec, hp, line, mono);
4981         return 1;
4982 }
4983
4984 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
4985         {
4986                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4987                 .name = "Master Playback Switch",
4988                 .info = snd_ctl_boolean_mono_info,
4989                 .get = alc260_hp_master_sw_get,
4990                 .put = alc260_hp_master_sw_put,
4991                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
4992         },
4993         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4994         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4995         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4996         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4997         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
4998                               HDA_OUTPUT),
4999         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5000         { } /* end */
5001 };
5002
5003 static struct hda_verb alc260_hp_unsol_verbs[] = {
5004         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5005         {},
5006 };
5007
5008 static void alc260_hp_automute(struct hda_codec *codec)
5009 {
5010         struct alc_spec *spec = codec->spec;
5011         unsigned int present;
5012
5013         present = snd_hda_codec_read(codec, 0x10, 0,
5014                                      AC_VERB_GET_PIN_SENSE, 0);
5015         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5016         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5017 }
5018
5019 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5020 {
5021         if ((res >> 26) == ALC880_HP_EVENT)
5022                 alc260_hp_automute(codec);
5023 }
5024
5025 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5026         {
5027                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5028                 .name = "Master Playback Switch",
5029                 .info = snd_ctl_boolean_mono_info,
5030                 .get = alc260_hp_master_sw_get,
5031                 .put = alc260_hp_master_sw_put,
5032                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5033         },
5034         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5035         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5036         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5037         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5038         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5039         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5040         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5041         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5042         { } /* end */
5043 };
5044
5045 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5046         .ops = &snd_hda_bind_vol,
5047         .values = {
5048                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5049                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5050                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5051                 0
5052         },
5053 };
5054
5055 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5056         .ops = &snd_hda_bind_sw,
5057         .values = {
5058                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5059                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5060                 0
5061         },
5062 };
5063
5064 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5065         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5066         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5067         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5068         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5069         { } /* end */
5070 };
5071
5072 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5073         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5074         {},
5075 };
5076
5077 static void alc260_hp_3013_automute(struct hda_codec *codec)
5078 {
5079         struct alc_spec *spec = codec->spec;
5080         unsigned int present;
5081
5082         present = snd_hda_codec_read(codec, 0x15, 0,
5083                                      AC_VERB_GET_PIN_SENSE, 0);
5084         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5085         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5086 }
5087
5088 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5089                                        unsigned int res)
5090 {
5091         if ((res >> 26) == ALC880_HP_EVENT)
5092                 alc260_hp_3013_automute(codec);
5093 }
5094
5095 static void alc260_hp_3012_automute(struct hda_codec *codec)
5096 {
5097         unsigned int present, bits;
5098
5099         present = snd_hda_codec_read(codec, 0x10, 0,
5100                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
5101
5102         bits = present ? 0 : PIN_OUT;
5103         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5104                             bits);
5105         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5106                             bits);
5107         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5108                             bits);
5109 }
5110
5111 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5112                                        unsigned int res)
5113 {
5114         if ((res >> 26) == ALC880_HP_EVENT)
5115                 alc260_hp_3012_automute(codec);
5116 }
5117
5118 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5119  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5120  */
5121 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5122         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5123         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5124         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5125         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5126         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5127         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5128         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5129         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5130         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5131         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5132         { } /* end */
5133 };
5134
5135 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5136  * versions of the ALC260 don't act on requests to enable mic bias from NID
5137  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5138  * datasheet doesn't mention this restriction.  At this stage it's not clear
5139  * whether this behaviour is intentional or is a hardware bug in chip
5140  * revisions available in early 2006.  Therefore for now allow the
5141  * "Headphone Jack Mode" control to span all choices, but if it turns out
5142  * that the lack of mic bias for this NID is intentional we could change the
5143  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5144  *
5145  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5146  * don't appear to make the mic bias available from the "line" jack, even
5147  * though the NID used for this jack (0x14) can supply it.  The theory is
5148  * that perhaps Acer have included blocking capacitors between the ALC260
5149  * and the output jack.  If this turns out to be the case for all such
5150  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5151  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5152  *
5153  * The C20x Tablet series have a mono internal speaker which is controlled
5154  * via the chip's Mono sum widget and pin complex, so include the necessary
5155  * controls for such models.  On models without a "mono speaker" the control
5156  * won't do anything.
5157  */
5158 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5159         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5160         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5161         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5162         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5163                               HDA_OUTPUT),
5164         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5165                            HDA_INPUT),
5166         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5167         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5168         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5169         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5170         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5171         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5172         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5173         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5174         { } /* end */
5175 };
5176
5177 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5178  */
5179 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5180         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5181         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5182         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5183         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5184         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5185         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5186         { } /* end */
5187 };
5188
5189 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5190  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5191  */
5192 static struct snd_kcontrol_new alc260_will_mixer[] = {
5193         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5194         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5195         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5196         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5197         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5198         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5199         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5200         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5201         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5202         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5203         { } /* end */
5204 };
5205
5206 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5207  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5208  */
5209 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5210         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5211         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5212         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5213         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5214         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5215         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5216         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5217         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5218         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5219         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5220         { } /* end */
5221 };
5222
5223 /*
5224  * initialization verbs
5225  */
5226 static struct hda_verb alc260_init_verbs[] = {
5227         /* Line In pin widget for input */
5228         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5229         /* CD pin widget for input */
5230         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5231         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5232         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5233         /* Mic2 (front panel) pin widget for input and vref at 80% */
5234         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5235         /* LINE-2 is used for line-out in rear */
5236         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5237         /* select line-out */
5238         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5239         /* LINE-OUT pin */
5240         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5241         /* enable HP */
5242         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5243         /* enable Mono */
5244         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5245         /* mute capture amp left and right */
5246         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5247         /* set connection select to line in (default select for this ADC) */
5248         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5249         /* mute capture amp left and right */
5250         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5251         /* set connection select to line in (default select for this ADC) */
5252         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5253         /* set vol=0 Line-Out mixer amp left and right */
5254         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5255         /* unmute pin widget amp left and right (no gain on this amp) */
5256         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5257         /* set vol=0 HP mixer amp left and right */
5258         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5259         /* unmute pin widget amp left and right (no gain on this amp) */
5260         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5261         /* set vol=0 Mono mixer amp left and right */
5262         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5263         /* unmute pin widget amp left and right (no gain on this amp) */
5264         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5265         /* unmute LINE-2 out pin */
5266         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5267         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5268          * Line In 2 = 0x03
5269          */
5270         /* mute analog inputs */
5271         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5272         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5273         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5274         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5275         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5276         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5277         /* mute Front out path */
5278         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5279         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5280         /* mute Headphone out path */
5281         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5282         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5283         /* mute Mono out path */
5284         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5285         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5286         { }
5287 };
5288
5289 #if 0 /* should be identical with alc260_init_verbs? */
5290 static struct hda_verb alc260_hp_init_verbs[] = {
5291         /* Headphone and output */
5292         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5293         /* mono output */
5294         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5295         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5296         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5297         /* Mic2 (front panel) pin widget for input and vref at 80% */
5298         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5299         /* Line In pin widget for input */
5300         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5301         /* Line-2 pin widget for output */
5302         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5303         /* CD pin widget for input */
5304         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5305         /* unmute amp left and right */
5306         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5307         /* set connection select to line in (default select for this ADC) */
5308         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5309         /* unmute Line-Out mixer amp left and right (volume = 0) */
5310         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5311         /* mute pin widget amp left and right (no gain on this amp) */
5312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5313         /* unmute HP mixer amp left and right (volume = 0) */
5314         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5315         /* mute pin widget amp left and right (no gain on this amp) */
5316         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5317         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5318          * Line In 2 = 0x03
5319          */
5320         /* mute analog inputs */
5321         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5322         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5323         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5324         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5325         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5326         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5327         /* Unmute Front out path */
5328         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5329         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5330         /* Unmute Headphone out path */
5331         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5332         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5333         /* Unmute Mono out path */
5334         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5335         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5336         { }
5337 };
5338 #endif
5339
5340 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5341         /* Line out and output */
5342         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5343         /* mono output */
5344         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5345         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5346         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5347         /* Mic2 (front panel) pin widget for input and vref at 80% */
5348         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5349         /* Line In pin widget for input */
5350         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5351         /* Headphone pin widget for output */
5352         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5353         /* CD pin widget for input */
5354         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5355         /* unmute amp left and right */
5356         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5357         /* set connection select to line in (default select for this ADC) */
5358         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5359         /* unmute Line-Out mixer amp left and right (volume = 0) */
5360         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5361         /* mute pin widget amp left and right (no gain on this amp) */
5362         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5363         /* unmute HP mixer amp left and right (volume = 0) */
5364         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5365         /* mute pin widget amp left and right (no gain on this amp) */
5366         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5367         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5368          * Line In 2 = 0x03
5369          */
5370         /* mute analog inputs */
5371         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5373         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5374         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5375         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5376         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5377         /* Unmute Front out path */
5378         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5379         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5380         /* Unmute Headphone out path */
5381         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5382         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5383         /* Unmute Mono out path */
5384         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5385         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5386         { }
5387 };
5388
5389 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5390  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5391  * audio = 0x16, internal speaker = 0x10.
5392  */
5393 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5394         /* Disable all GPIOs */
5395         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5396         /* Internal speaker is connected to headphone pin */
5397         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5398         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5399         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5400         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5401         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5402         /* Ensure all other unused pins are disabled and muted. */
5403         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5404         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5405         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5406         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5407         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5408         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5409         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5410         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5411
5412         /* Disable digital (SPDIF) pins */
5413         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5414         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5415
5416         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5417          * when acting as an output.
5418          */
5419         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5420
5421         /* Start with output sum widgets muted and their output gains at min */
5422         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5423         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5424         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5425         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5426         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5427         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5428         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5429         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5430         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5431
5432         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5433         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5434         /* Unmute Line1 pin widget output buffer since it starts as an output.
5435          * If the pin mode is changed by the user the pin mode control will
5436          * take care of enabling the pin's input/output buffers as needed.
5437          * Therefore there's no need to enable the input buffer at this
5438          * stage.
5439          */
5440         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5441         /* Unmute input buffer of pin widget used for Line-in (no equiv
5442          * mixer ctrl)
5443          */
5444         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5445
5446         /* Mute capture amp left and right */
5447         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5448         /* Set ADC connection select to match default mixer setting - line
5449          * in (on mic1 pin)
5450          */
5451         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5452
5453         /* Do the same for the second ADC: mute capture input amp and
5454          * set ADC connection to line in (on mic1 pin)
5455          */
5456         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5457         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5458
5459         /* Mute all inputs to mixer widget (even unconnected ones) */
5460         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5461         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5462         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5463         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5464         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5465         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5466         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5467         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5468
5469         { }
5470 };
5471
5472 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5473  * similar laptops (adapted from Fujitsu init verbs).
5474  */
5475 static struct hda_verb alc260_acer_init_verbs[] = {
5476         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5477          * the headphone jack.  Turn this on and rely on the standard mute
5478          * methods whenever the user wants to turn these outputs off.
5479          */
5480         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5481         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5482         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5483         /* Internal speaker/Headphone jack is connected to Line-out pin */
5484         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5485         /* Internal microphone/Mic jack is connected to Mic1 pin */
5486         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5487         /* Line In jack is connected to Line1 pin */
5488         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5489         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5490         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5491         /* Ensure all other unused pins are disabled and muted. */
5492         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5493         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5494         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5495         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5496         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5497         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5498         /* Disable digital (SPDIF) pins */
5499         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5500         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5501
5502         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5503          * bus when acting as outputs.
5504          */
5505         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5506         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5507
5508         /* Start with output sum widgets muted and their output gains at min */
5509         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5510         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5511         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5512         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5513         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5514         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5515         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5516         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5517         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5518
5519         /* Unmute Line-out pin widget amp left and right
5520          * (no equiv mixer ctrl)
5521          */
5522         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5523         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5524         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5525         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5526          * inputs. If the pin mode is changed by the user the pin mode control
5527          * will take care of enabling the pin's input/output buffers as needed.
5528          * Therefore there's no need to enable the input buffer at this
5529          * stage.
5530          */
5531         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5532         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5533
5534         /* Mute capture amp left and right */
5535         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5536         /* Set ADC connection select to match default mixer setting - mic
5537          * (on mic1 pin)
5538          */
5539         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5540
5541         /* Do similar with the second ADC: mute capture input amp and
5542          * set ADC connection to mic to match ALSA's default state.
5543          */
5544         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5545         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5546
5547         /* Mute all inputs to mixer widget (even unconnected ones) */
5548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5550         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5551         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5552         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5553         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5554         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5555         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5556
5557         { }
5558 };
5559
5560 /* Initialisation sequence for Maxdata Favorit 100XS
5561  * (adapted from Acer init verbs).
5562  */
5563 static struct hda_verb alc260_favorit100_init_verbs[] = {
5564         /* GPIO 0 enables the output jack.
5565          * Turn this on and rely on the standard mute
5566          * methods whenever the user wants to turn these outputs off.
5567          */
5568         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5569         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5570         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5571         /* Line/Mic input jack is connected to Mic1 pin */
5572         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5573         /* Ensure all other unused pins are disabled and muted. */
5574         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5575         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5576         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5577         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5578         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5579         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5580         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5581         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5582         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5583         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5584         /* Disable digital (SPDIF) pins */
5585         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5586         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5587
5588         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5589          * bus when acting as outputs.
5590          */
5591         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5592         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5593
5594         /* Start with output sum widgets muted and their output gains at min */
5595         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5596         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5597         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5598         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5599         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5600         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5601         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5602         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5603         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5604
5605         /* Unmute Line-out pin widget amp left and right
5606          * (no equiv mixer ctrl)
5607          */
5608         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5609         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5610          * inputs. If the pin mode is changed by the user the pin mode control
5611          * will take care of enabling the pin's input/output buffers as needed.
5612          * Therefore there's no need to enable the input buffer at this
5613          * stage.
5614          */
5615         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5616
5617         /* Mute capture amp left and right */
5618         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5619         /* Set ADC connection select to match default mixer setting - mic
5620          * (on mic1 pin)
5621          */
5622         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5623
5624         /* Do similar with the second ADC: mute capture input amp and
5625          * set ADC connection to mic to match ALSA's default state.
5626          */
5627         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5628         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5629
5630         /* Mute all inputs to mixer widget (even unconnected ones) */
5631         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5632         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5633         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5634         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5635         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5636         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5637         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5638         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5639
5640         { }
5641 };
5642
5643 static struct hda_verb alc260_will_verbs[] = {
5644         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5645         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5646         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5647         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5648         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5649         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5650         {}
5651 };
5652
5653 static struct hda_verb alc260_replacer_672v_verbs[] = {
5654         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5655         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5656         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5657
5658         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5659         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5660         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5661
5662         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5663         {}
5664 };
5665
5666 /* toggle speaker-output according to the hp-jack state */
5667 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5668 {
5669         unsigned int present;
5670
5671         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5672         present = snd_hda_codec_read(codec, 0x0f, 0,
5673                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5674         if (present) {
5675                 snd_hda_codec_write_cache(codec, 0x01, 0,
5676                                           AC_VERB_SET_GPIO_DATA, 1);
5677                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5678                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5679                                           PIN_HP);
5680         } else {
5681                 snd_hda_codec_write_cache(codec, 0x01, 0,
5682                                           AC_VERB_SET_GPIO_DATA, 0);
5683                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5684                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5685                                           PIN_OUT);
5686         }
5687 }
5688
5689 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5690                                        unsigned int res)
5691 {
5692         if ((res >> 26) == ALC880_HP_EVENT)
5693                 alc260_replacer_672v_automute(codec);
5694 }
5695
5696 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5697         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5698         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5699         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5700         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5701         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5702         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5703         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5704         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5705         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5706         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5707         {}
5708 };
5709
5710 /* Test configuration for debugging, modelled after the ALC880 test
5711  * configuration.
5712  */
5713 #ifdef CONFIG_SND_DEBUG
5714 static hda_nid_t alc260_test_dac_nids[1] = {
5715         0x02,
5716 };
5717 static hda_nid_t alc260_test_adc_nids[2] = {
5718         0x04, 0x05,
5719 };
5720 /* For testing the ALC260, each input MUX needs its own definition since
5721  * the signal assignments are different.  This assumes that the first ADC
5722  * is NID 0x04.
5723  */
5724 static struct hda_input_mux alc260_test_capture_sources[2] = {
5725         {
5726                 .num_items = 7,
5727                 .items = {
5728                         { "MIC1 pin", 0x0 },
5729                         { "MIC2 pin", 0x1 },
5730                         { "LINE1 pin", 0x2 },
5731                         { "LINE2 pin", 0x3 },
5732                         { "CD pin", 0x4 },
5733                         { "LINE-OUT pin", 0x5 },
5734                         { "HP-OUT pin", 0x6 },
5735                 },
5736         },
5737         {
5738                 .num_items = 8,
5739                 .items = {
5740                         { "MIC1 pin", 0x0 },
5741                         { "MIC2 pin", 0x1 },
5742                         { "LINE1 pin", 0x2 },
5743                         { "LINE2 pin", 0x3 },
5744                         { "CD pin", 0x4 },
5745                         { "Mixer", 0x5 },
5746                         { "LINE-OUT pin", 0x6 },
5747                         { "HP-OUT pin", 0x7 },
5748                 },
5749         },
5750 };
5751 static struct snd_kcontrol_new alc260_test_mixer[] = {
5752         /* Output driver widgets */
5753         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5754         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5755         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5756         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5757         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5758         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5759
5760         /* Modes for retasking pin widgets
5761          * Note: the ALC260 doesn't seem to act on requests to enable mic
5762          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5763          * mention this restriction.  At this stage it's not clear whether
5764          * this behaviour is intentional or is a hardware bug in chip
5765          * revisions available at least up until early 2006.  Therefore for
5766          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5767          * choices, but if it turns out that the lack of mic bias for these
5768          * NIDs is intentional we could change their modes from
5769          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5770          */
5771         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5772         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5773         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5774         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5775         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5776         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5777
5778         /* Loopback mixer controls */
5779         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5780         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5781         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5782         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5783         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5784         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5785         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5786         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5787         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5788         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5789         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5790         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5791         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5792         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5793
5794         /* Controls for GPIO pins, assuming they are configured as outputs */
5795         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5796         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5797         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5798         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5799
5800         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5801          * is ambigious as to which NID is which; testing on laptops which
5802          * make this output available should provide clarification.
5803          */
5804         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5805         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5806
5807         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5808          * this output to turn on an external amplifier.
5809          */
5810         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5811         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5812
5813         { } /* end */
5814 };
5815 static struct hda_verb alc260_test_init_verbs[] = {
5816         /* Enable all GPIOs as outputs with an initial value of 0 */
5817         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5818         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5819         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5820
5821         /* Enable retasking pins as output, initially without power amp */
5822         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5823         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5824         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5825         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5826         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5827         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5828
5829         /* Disable digital (SPDIF) pins initially, but users can enable
5830          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5831          * payload also sets the generation to 0, output to be in "consumer"
5832          * PCM format, copyright asserted, no pre-emphasis and no validity
5833          * control.
5834          */
5835         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5836         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5837
5838         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5839          * OUT1 sum bus when acting as an output.
5840          */
5841         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5842         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5843         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5844         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5845
5846         /* Start with output sum widgets muted and their output gains at min */
5847         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5848         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5849         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5850         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5851         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5852         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5853         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5854         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5855         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5856
5857         /* Unmute retasking pin widget output buffers since the default
5858          * state appears to be output.  As the pin mode is changed by the
5859          * user the pin mode control will take care of enabling the pin's
5860          * input/output buffers as needed.
5861          */
5862         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5863         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5864         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5865         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5866         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5867         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5868         /* Also unmute the mono-out pin widget */
5869         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5870
5871         /* Mute capture amp left and right */
5872         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5873         /* Set ADC connection select to match default mixer setting (mic1
5874          * pin)
5875          */
5876         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5877
5878         /* Do the same for the second ADC: mute capture input amp and
5879          * set ADC connection to mic1 pin
5880          */
5881         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5882         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5883
5884         /* Mute all inputs to mixer widget (even unconnected ones) */
5885         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5886         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5887         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5888         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5889         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5890         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5891         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5892         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5893
5894         { }
5895 };
5896 #endif
5897
5898 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5899 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5900
5901 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5902 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5903
5904 /*
5905  * for BIOS auto-configuration
5906  */
5907
5908 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5909                                         const char *pfx, int *vol_bits)
5910 {
5911         hda_nid_t nid_vol;
5912         unsigned long vol_val, sw_val;
5913         char name[32];
5914         int err;
5915
5916         if (nid >= 0x0f && nid < 0x11) {
5917                 nid_vol = nid - 0x7;
5918                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5919                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5920         } else if (nid == 0x11) {
5921                 nid_vol = nid - 0x7;
5922                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
5923                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
5924         } else if (nid >= 0x12 && nid <= 0x15) {
5925                 nid_vol = 0x08;
5926                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5927                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5928         } else
5929                 return 0; /* N/A */
5930
5931         if (!(*vol_bits & (1 << nid_vol))) {
5932                 /* first control for the volume widget */
5933                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
5934                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
5935                 if (err < 0)
5936                         return err;
5937                 *vol_bits |= (1 << nid_vol);
5938         }
5939         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
5940         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
5941         if (err < 0)
5942                 return err;
5943         return 1;
5944 }
5945
5946 /* add playback controls from the parsed DAC table */
5947 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
5948                                              const struct auto_pin_cfg *cfg)
5949 {
5950         hda_nid_t nid;
5951         int err;
5952         int vols = 0;
5953
5954         spec->multiout.num_dacs = 1;
5955         spec->multiout.dac_nids = spec->private_dac_nids;
5956         spec->multiout.dac_nids[0] = 0x02;
5957
5958         nid = cfg->line_out_pins[0];
5959         if (nid) {
5960                 err = alc260_add_playback_controls(spec, nid, "Front", &vols);
5961                 if (err < 0)
5962                         return err;
5963         }
5964
5965         nid = cfg->speaker_pins[0];
5966         if (nid) {
5967                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
5968                 if (err < 0)
5969                         return err;
5970         }
5971
5972         nid = cfg->hp_pins[0];
5973         if (nid) {
5974                 err = alc260_add_playback_controls(spec, nid, "Headphone",
5975                                                    &vols);
5976                 if (err < 0)
5977                         return err;
5978         }
5979         return 0;
5980 }
5981
5982 /* create playback/capture controls for input pins */
5983 static int alc260_auto_create_analog_input_ctls(struct alc_spec *spec,
5984                                                 const struct auto_pin_cfg *cfg)
5985 {
5986         struct hda_input_mux *imux = &spec->private_imux[0];
5987         int i, err, idx;
5988
5989         for (i = 0; i < AUTO_PIN_LAST; i++) {
5990                 if (cfg->input_pins[i] >= 0x12) {
5991                         idx = cfg->input_pins[i] - 0x12;
5992                         err = new_analog_input(spec, cfg->input_pins[i],
5993                                                auto_pin_cfg_labels[i], idx,
5994                                                0x07);
5995                         if (err < 0)
5996                                 return err;
5997                         imux->items[imux->num_items].label =
5998                                 auto_pin_cfg_labels[i];
5999                         imux->items[imux->num_items].index = idx;
6000                         imux->num_items++;
6001                 }
6002                 if (cfg->input_pins[i] >= 0x0f && cfg->input_pins[i] <= 0x10){
6003                         idx = cfg->input_pins[i] - 0x09;
6004                         err = new_analog_input(spec, cfg->input_pins[i],
6005                                                auto_pin_cfg_labels[i], idx,
6006                                                0x07);
6007                         if (err < 0)
6008                                 return err;
6009                         imux->items[imux->num_items].label =
6010                                 auto_pin_cfg_labels[i];
6011                         imux->items[imux->num_items].index = idx;
6012                         imux->num_items++;
6013                 }
6014         }
6015         return 0;
6016 }
6017
6018 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6019                                               hda_nid_t nid, int pin_type,
6020                                               int sel_idx)
6021 {
6022         alc_set_pin_output(codec, nid, pin_type);
6023         /* need the manual connection? */
6024         if (nid >= 0x12) {
6025                 int idx = nid - 0x12;
6026                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6027                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6028         }
6029 }
6030
6031 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6032 {
6033         struct alc_spec *spec = codec->spec;
6034         hda_nid_t nid;
6035
6036         nid = spec->autocfg.line_out_pins[0];
6037         if (nid) {
6038                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6039                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6040         }
6041
6042         nid = spec->autocfg.speaker_pins[0];
6043         if (nid)
6044                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6045
6046         nid = spec->autocfg.hp_pins[0];
6047         if (nid)
6048                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6049 }
6050
6051 #define ALC260_PIN_CD_NID               0x16
6052 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6053 {
6054         struct alc_spec *spec = codec->spec;
6055         int i;
6056
6057         for (i = 0; i < AUTO_PIN_LAST; i++) {
6058                 hda_nid_t nid = spec->autocfg.input_pins[i];
6059                 if (nid >= 0x12) {
6060                         alc_set_input_pin(codec, nid, i);
6061                         if (nid != ALC260_PIN_CD_NID &&
6062                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6063                                 snd_hda_codec_write(codec, nid, 0,
6064                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6065                                                     AMP_OUT_MUTE);
6066                 }
6067         }
6068 }
6069
6070 /*
6071  * generic initialization of ADC, input mixers and output mixers
6072  */
6073 static struct hda_verb alc260_volume_init_verbs[] = {
6074         /*
6075          * Unmute ADC0-1 and set the default input to mic-in
6076          */
6077         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6078         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6079         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6080         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6081
6082         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6083          * mixer widget
6084          * Note: PASD motherboards uses the Line In 2 as the input for
6085          * front panel mic (mic 2)
6086          */
6087         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6088         /* mute analog inputs */
6089         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6090         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6091         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6092         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6093         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6094
6095         /*
6096          * Set up output mixers (0x08 - 0x0a)
6097          */
6098         /* set vol=0 to output mixers */
6099         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6100         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6101         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6102         /* set up input amps for analog loopback */
6103         /* Amp Indices: DAC = 0, mixer = 1 */
6104         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6105         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6106         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6107         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6108         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6109         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6110
6111         { }
6112 };
6113
6114 static int alc260_parse_auto_config(struct hda_codec *codec)
6115 {
6116         struct alc_spec *spec = codec->spec;
6117         int err;
6118         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6119
6120         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6121                                            alc260_ignore);
6122         if (err < 0)
6123                 return err;
6124         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6125         if (err < 0)
6126                 return err;
6127         if (!spec->kctls.list)
6128                 return 0; /* can't find valid BIOS pin config */
6129         err = alc260_auto_create_analog_input_ctls(spec, &spec->autocfg);
6130         if (err < 0)
6131                 return err;
6132
6133         spec->multiout.max_channels = 2;
6134
6135         if (spec->autocfg.dig_outs)
6136                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6137         if (spec->kctls.list)
6138                 add_mixer(spec, spec->kctls.list);
6139
6140         add_verb(spec, alc260_volume_init_verbs);
6141
6142         spec->num_mux_defs = 1;
6143         spec->input_mux = &spec->private_imux[0];
6144
6145         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6146
6147         return 1;
6148 }
6149
6150 /* additional initialization for auto-configuration model */
6151 static void alc260_auto_init(struct hda_codec *codec)
6152 {
6153         struct alc_spec *spec = codec->spec;
6154         alc260_auto_init_multi_out(codec);
6155         alc260_auto_init_analog_input(codec);
6156         if (spec->unsol_event)
6157                 alc_inithook(codec);
6158 }
6159
6160 #ifdef CONFIG_SND_HDA_POWER_SAVE
6161 static struct hda_amp_list alc260_loopbacks[] = {
6162         { 0x07, HDA_INPUT, 0 },
6163         { 0x07, HDA_INPUT, 1 },
6164         { 0x07, HDA_INPUT, 2 },
6165         { 0x07, HDA_INPUT, 3 },
6166         { 0x07, HDA_INPUT, 4 },
6167         { } /* end */
6168 };
6169 #endif
6170
6171 /*
6172  * ALC260 configurations
6173  */
6174 static const char *alc260_models[ALC260_MODEL_LAST] = {
6175         [ALC260_BASIC]          = "basic",
6176         [ALC260_HP]             = "hp",
6177         [ALC260_HP_3013]        = "hp-3013",
6178         [ALC260_HP_DC7600]      = "hp-dc7600",
6179         [ALC260_FUJITSU_S702X]  = "fujitsu",
6180         [ALC260_ACER]           = "acer",
6181         [ALC260_WILL]           = "will",
6182         [ALC260_REPLACER_672V]  = "replacer",
6183         [ALC260_FAVORIT100]     = "favorit100",
6184 #ifdef CONFIG_SND_DEBUG
6185         [ALC260_TEST]           = "test",
6186 #endif
6187         [ALC260_AUTO]           = "auto",
6188 };
6189
6190 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6191         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6192         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6193         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6194         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6195         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
6196         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6197         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6198         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6199         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6200         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6201         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6202         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6203         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6204         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6205         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6206         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6207         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6208         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6209         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6210         {}
6211 };
6212
6213 static struct alc_config_preset alc260_presets[] = {
6214         [ALC260_BASIC] = {
6215                 .mixers = { alc260_base_output_mixer,
6216                             alc260_input_mixer },
6217                 .init_verbs = { alc260_init_verbs },
6218                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6219                 .dac_nids = alc260_dac_nids,
6220                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6221                 .adc_nids = alc260_adc_nids,
6222                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6223                 .channel_mode = alc260_modes,
6224                 .input_mux = &alc260_capture_source,
6225         },
6226         [ALC260_HP] = {
6227                 .mixers = { alc260_hp_output_mixer,
6228                             alc260_input_mixer },
6229                 .init_verbs = { alc260_init_verbs,
6230                                 alc260_hp_unsol_verbs },
6231                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6232                 .dac_nids = alc260_dac_nids,
6233                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6234                 .adc_nids = alc260_adc_nids_alt,
6235                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6236                 .channel_mode = alc260_modes,
6237                 .input_mux = &alc260_capture_source,
6238                 .unsol_event = alc260_hp_unsol_event,
6239                 .init_hook = alc260_hp_automute,
6240         },
6241         [ALC260_HP_DC7600] = {
6242                 .mixers = { alc260_hp_dc7600_mixer,
6243                             alc260_input_mixer },
6244                 .init_verbs = { alc260_init_verbs,
6245                                 alc260_hp_dc7600_verbs },
6246                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6247                 .dac_nids = alc260_dac_nids,
6248                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6249                 .adc_nids = alc260_adc_nids_alt,
6250                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6251                 .channel_mode = alc260_modes,
6252                 .input_mux = &alc260_capture_source,
6253                 .unsol_event = alc260_hp_3012_unsol_event,
6254                 .init_hook = alc260_hp_3012_automute,
6255         },
6256         [ALC260_HP_3013] = {
6257                 .mixers = { alc260_hp_3013_mixer,
6258                             alc260_input_mixer },
6259                 .init_verbs = { alc260_hp_3013_init_verbs,
6260                                 alc260_hp_3013_unsol_verbs },
6261                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6262                 .dac_nids = alc260_dac_nids,
6263                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6264                 .adc_nids = alc260_adc_nids_alt,
6265                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6266                 .channel_mode = alc260_modes,
6267                 .input_mux = &alc260_capture_source,
6268                 .unsol_event = alc260_hp_3013_unsol_event,
6269                 .init_hook = alc260_hp_3013_automute,
6270         },
6271         [ALC260_FUJITSU_S702X] = {
6272                 .mixers = { alc260_fujitsu_mixer },
6273                 .init_verbs = { alc260_fujitsu_init_verbs },
6274                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6275                 .dac_nids = alc260_dac_nids,
6276                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6277                 .adc_nids = alc260_dual_adc_nids,
6278                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6279                 .channel_mode = alc260_modes,
6280                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6281                 .input_mux = alc260_fujitsu_capture_sources,
6282         },
6283         [ALC260_ACER] = {
6284                 .mixers = { alc260_acer_mixer },
6285                 .init_verbs = { alc260_acer_init_verbs },
6286                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6287                 .dac_nids = alc260_dac_nids,
6288                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6289                 .adc_nids = alc260_dual_adc_nids,
6290                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6291                 .channel_mode = alc260_modes,
6292                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6293                 .input_mux = alc260_acer_capture_sources,
6294         },
6295         [ALC260_FAVORIT100] = {
6296                 .mixers = { alc260_favorit100_mixer },
6297                 .init_verbs = { alc260_favorit100_init_verbs },
6298                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6299                 .dac_nids = alc260_dac_nids,
6300                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6301                 .adc_nids = alc260_dual_adc_nids,
6302                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6303                 .channel_mode = alc260_modes,
6304                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6305                 .input_mux = alc260_favorit100_capture_sources,
6306         },
6307         [ALC260_WILL] = {
6308                 .mixers = { alc260_will_mixer },
6309                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6310                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6311                 .dac_nids = alc260_dac_nids,
6312                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6313                 .adc_nids = alc260_adc_nids,
6314                 .dig_out_nid = ALC260_DIGOUT_NID,
6315                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6316                 .channel_mode = alc260_modes,
6317                 .input_mux = &alc260_capture_source,
6318         },
6319         [ALC260_REPLACER_672V] = {
6320                 .mixers = { alc260_replacer_672v_mixer },
6321                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6322                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6323                 .dac_nids = alc260_dac_nids,
6324                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6325                 .adc_nids = alc260_adc_nids,
6326                 .dig_out_nid = ALC260_DIGOUT_NID,
6327                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6328                 .channel_mode = alc260_modes,
6329                 .input_mux = &alc260_capture_source,
6330                 .unsol_event = alc260_replacer_672v_unsol_event,
6331                 .init_hook = alc260_replacer_672v_automute,
6332         },
6333 #ifdef CONFIG_SND_DEBUG
6334         [ALC260_TEST] = {
6335                 .mixers = { alc260_test_mixer },
6336                 .init_verbs = { alc260_test_init_verbs },
6337                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6338                 .dac_nids = alc260_test_dac_nids,
6339                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6340                 .adc_nids = alc260_test_adc_nids,
6341                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6342                 .channel_mode = alc260_modes,
6343                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6344                 .input_mux = alc260_test_capture_sources,
6345         },
6346 #endif
6347 };
6348
6349 static int patch_alc260(struct hda_codec *codec)
6350 {
6351         struct alc_spec *spec;
6352         int err, board_config;
6353
6354         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6355         if (spec == NULL)
6356                 return -ENOMEM;
6357
6358         codec->spec = spec;
6359
6360         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6361                                                   alc260_models,
6362                                                   alc260_cfg_tbl);
6363         if (board_config < 0) {
6364                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6365                            codec->chip_name);
6366                 board_config = ALC260_AUTO;
6367         }
6368
6369         if (board_config == ALC260_AUTO) {
6370                 /* automatic parse from the BIOS config */
6371                 err = alc260_parse_auto_config(codec);
6372                 if (err < 0) {
6373                         alc_free(codec);
6374                         return err;
6375                 } else if (!err) {
6376                         printk(KERN_INFO
6377                                "hda_codec: Cannot set up configuration "
6378                                "from BIOS.  Using base mode...\n");
6379                         board_config = ALC260_BASIC;
6380                 }
6381         }
6382
6383         err = snd_hda_attach_beep_device(codec, 0x1);
6384         if (err < 0) {
6385                 alc_free(codec);
6386                 return err;
6387         }
6388
6389         if (board_config != ALC260_AUTO)
6390                 setup_preset(spec, &alc260_presets[board_config]);
6391
6392         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6393         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6394
6395         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6396         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6397
6398         if (!spec->adc_nids && spec->input_mux) {
6399                 /* check whether NID 0x04 is valid */
6400                 unsigned int wcap = get_wcaps(codec, 0x04);
6401                 wcap = get_wcaps_type(wcap);
6402                 /* get type */
6403                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6404                         spec->adc_nids = alc260_adc_nids_alt;
6405                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6406                 } else {
6407                         spec->adc_nids = alc260_adc_nids;
6408                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6409                 }
6410         }
6411         set_capture_mixer(spec);
6412         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6413
6414         spec->vmaster_nid = 0x08;
6415
6416         codec->patch_ops = alc_patch_ops;
6417         if (board_config == ALC260_AUTO)
6418                 spec->init_hook = alc260_auto_init;
6419 #ifdef CONFIG_SND_HDA_POWER_SAVE
6420         if (!spec->loopback.amplist)
6421                 spec->loopback.amplist = alc260_loopbacks;
6422 #endif
6423         codec->proc_widget_hook = print_realtek_coef;
6424
6425         return 0;
6426 }
6427
6428
6429 /*
6430  * ALC882/883/885/888/889 support
6431  *
6432  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6433  * configuration.  Each pin widget can choose any input DACs and a mixer.
6434  * Each ADC is connected from a mixer of all inputs.  This makes possible
6435  * 6-channel independent captures.
6436  *
6437  * In addition, an independent DAC for the multi-playback (not used in this
6438  * driver yet).
6439  */
6440 #define ALC882_DIGOUT_NID       0x06
6441 #define ALC882_DIGIN_NID        0x0a
6442 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6443 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6444 #define ALC1200_DIGOUT_NID      0x10
6445
6446
6447 static struct hda_channel_mode alc882_ch_modes[1] = {
6448         { 8, NULL }
6449 };
6450
6451 /* DACs */
6452 static hda_nid_t alc882_dac_nids[4] = {
6453         /* front, rear, clfe, rear_surr */
6454         0x02, 0x03, 0x04, 0x05
6455 };
6456 #define alc883_dac_nids         alc882_dac_nids
6457
6458 /* ADCs */
6459 #define alc882_adc_nids         alc880_adc_nids
6460 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6461 #define alc883_adc_nids         alc882_adc_nids_alt
6462 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6463 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6464 #define alc889_adc_nids         alc880_adc_nids
6465
6466 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6467 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6468 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6469 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6470 #define alc889_capsrc_nids      alc882_capsrc_nids
6471
6472 /* input MUX */
6473 /* FIXME: should be a matrix-type input source selection */
6474
6475 static struct hda_input_mux alc882_capture_source = {
6476         .num_items = 4,
6477         .items = {
6478                 { "Mic", 0x0 },
6479                 { "Front Mic", 0x1 },
6480                 { "Line", 0x2 },
6481                 { "CD", 0x4 },
6482         },
6483 };
6484
6485 #define alc883_capture_source   alc882_capture_source
6486
6487 static struct hda_input_mux alc889_capture_source = {
6488         .num_items = 3,
6489         .items = {
6490                 { "Front Mic", 0x0 },
6491                 { "Mic", 0x3 },
6492                 { "Line", 0x2 },
6493         },
6494 };
6495
6496 static struct hda_input_mux mb5_capture_source = {
6497         .num_items = 3,
6498         .items = {
6499                 { "Mic", 0x1 },
6500                 { "Line", 0x2 },
6501                 { "CD", 0x4 },
6502         },
6503 };
6504
6505 static struct hda_input_mux alc883_3stack_6ch_intel = {
6506         .num_items = 4,
6507         .items = {
6508                 { "Mic", 0x1 },
6509                 { "Front Mic", 0x0 },
6510                 { "Line", 0x2 },
6511                 { "CD", 0x4 },
6512         },
6513 };
6514
6515 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6516         .num_items = 2,
6517         .items = {
6518                 { "Mic", 0x1 },
6519                 { "Line", 0x2 },
6520         },
6521 };
6522
6523 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6524         .num_items = 4,
6525         .items = {
6526                 { "Mic", 0x0 },
6527                 { "iMic", 0x1 },
6528                 { "Line", 0x2 },
6529                 { "CD", 0x4 },
6530         },
6531 };
6532
6533 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6534         .num_items = 2,
6535         .items = {
6536                 { "Mic", 0x0 },
6537                 { "Int Mic", 0x1 },
6538         },
6539 };
6540
6541 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6542         .num_items = 3,
6543         .items = {
6544                 { "Mic", 0x0 },
6545                 { "Front Mic", 0x1 },
6546                 { "Line", 0x4 },
6547         },
6548 };
6549
6550 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6551         .num_items = 2,
6552         .items = {
6553                 { "Mic", 0x0 },
6554                 { "Line", 0x2 },
6555         },
6556 };
6557
6558 static struct hda_input_mux alc889A_mb31_capture_source = {
6559         .num_items = 2,
6560         .items = {
6561                 { "Mic", 0x0 },
6562                 /* Front Mic (0x01) unused */
6563                 { "Line", 0x2 },
6564                 /* Line 2 (0x03) unused */
6565                 /* CD (0x04) unsused? */
6566         },
6567 };
6568
6569 /*
6570  * 2ch mode
6571  */
6572 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6573         { 2, NULL }
6574 };
6575
6576 /*
6577  * 2ch mode
6578  */
6579 static struct hda_verb alc882_3ST_ch2_init[] = {
6580         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6581         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6582         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6583         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6584         { } /* end */
6585 };
6586
6587 /*
6588  * 4ch mode
6589  */
6590 static struct hda_verb alc882_3ST_ch4_init[] = {
6591         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6592         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6593         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6594         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6595         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6596         { } /* end */
6597 };
6598
6599 /*
6600  * 6ch mode
6601  */
6602 static struct hda_verb alc882_3ST_ch6_init[] = {
6603         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6604         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6605         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6606         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6607         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6608         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6609         { } /* end */
6610 };
6611
6612 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6613         { 2, alc882_3ST_ch2_init },
6614         { 4, alc882_3ST_ch4_init },
6615         { 6, alc882_3ST_ch6_init },
6616 };
6617
6618 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6619
6620 /*
6621  * 6ch mode
6622  */
6623 static struct hda_verb alc882_sixstack_ch6_init[] = {
6624         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6625         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6626         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6627         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6628         { } /* end */
6629 };
6630
6631 /*
6632  * 8ch mode
6633  */
6634 static struct hda_verb alc882_sixstack_ch8_init[] = {
6635         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6636         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6637         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6638         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6639         { } /* end */
6640 };
6641
6642 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6643         { 6, alc882_sixstack_ch6_init },
6644         { 8, alc882_sixstack_ch8_init },
6645 };
6646
6647 /*
6648  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6649  */
6650
6651 /*
6652  * 2ch mode
6653  */
6654 static struct hda_verb alc885_mbp_ch2_init[] = {
6655         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6656         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6657         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6658         { } /* end */
6659 };
6660
6661 /*
6662  * 6ch mode
6663  */
6664 static struct hda_verb alc885_mbp_ch6_init[] = {
6665         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6666         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6667         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6668         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6669         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6670         { } /* end */
6671 };
6672
6673 static struct hda_channel_mode alc885_mbp_6ch_modes[2] = {
6674         { 2, alc885_mbp_ch2_init },
6675         { 6, alc885_mbp_ch6_init },
6676 };
6677
6678 /*
6679  * 2ch
6680  * Speakers/Woofer/HP = Front
6681  * LineIn = Input
6682  */
6683 static struct hda_verb alc885_mb5_ch2_init[] = {
6684         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6685         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6686         { } /* end */
6687 };
6688
6689 /*
6690  * 6ch mode
6691  * Speakers/HP = Front
6692  * Woofer = LFE
6693  * LineIn = Surround
6694  */
6695 static struct hda_verb alc885_mb5_ch6_init[] = {
6696         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6697         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6698         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6699         { } /* end */
6700 };
6701
6702 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6703         { 2, alc885_mb5_ch2_init },
6704         { 6, alc885_mb5_ch6_init },
6705 };
6706
6707
6708 /*
6709  * 2ch mode
6710  */
6711 static struct hda_verb alc883_4ST_ch2_init[] = {
6712         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6713         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6714         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6715         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6716         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6717         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6718         { } /* end */
6719 };
6720
6721 /*
6722  * 4ch mode
6723  */
6724 static struct hda_verb alc883_4ST_ch4_init[] = {
6725         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6726         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6727         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6728         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6729         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6730         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6731         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6732         { } /* end */
6733 };
6734
6735 /*
6736  * 6ch mode
6737  */
6738 static struct hda_verb alc883_4ST_ch6_init[] = {
6739         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6740         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6741         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6742         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6743         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6744         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6745         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6746         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6747         { } /* end */
6748 };
6749
6750 /*
6751  * 8ch mode
6752  */
6753 static struct hda_verb alc883_4ST_ch8_init[] = {
6754         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6755         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6756         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6757         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6758         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6759         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6760         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6761         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6762         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6763         { } /* end */
6764 };
6765
6766 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6767         { 2, alc883_4ST_ch2_init },
6768         { 4, alc883_4ST_ch4_init },
6769         { 6, alc883_4ST_ch6_init },
6770         { 8, alc883_4ST_ch8_init },
6771 };
6772
6773
6774 /*
6775  * 2ch mode
6776  */
6777 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6778         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6779         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6780         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6781         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6782         { } /* end */
6783 };
6784
6785 /*
6786  * 4ch mode
6787  */
6788 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6789         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6790         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6791         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6792         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6793         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6794         { } /* end */
6795 };
6796
6797 /*
6798  * 6ch mode
6799  */
6800 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6801         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6802         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6803         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6804         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6805         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6806         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6807         { } /* end */
6808 };
6809
6810 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6811         { 2, alc883_3ST_ch2_intel_init },
6812         { 4, alc883_3ST_ch4_intel_init },
6813         { 6, alc883_3ST_ch6_intel_init },
6814 };
6815
6816 /*
6817  * 2ch mode
6818  */
6819 static struct hda_verb alc889_ch2_intel_init[] = {
6820         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6821         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
6822         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
6823         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
6824         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6825         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6826         { } /* end */
6827 };
6828
6829 /*
6830  * 6ch mode
6831  */
6832 static struct hda_verb alc889_ch6_intel_init[] = {
6833         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6834         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6835         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6836         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6837         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6838         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6839         { } /* end */
6840 };
6841
6842 /*
6843  * 8ch mode
6844  */
6845 static struct hda_verb alc889_ch8_intel_init[] = {
6846         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6847         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6848         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6849         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6850         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
6851         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6852         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6853         { } /* end */
6854 };
6855
6856 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
6857         { 2, alc889_ch2_intel_init },
6858         { 6, alc889_ch6_intel_init },
6859         { 8, alc889_ch8_intel_init },
6860 };
6861
6862 /*
6863  * 6ch mode
6864  */
6865 static struct hda_verb alc883_sixstack_ch6_init[] = {
6866         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6867         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6868         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6869         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6870         { } /* end */
6871 };
6872
6873 /*
6874  * 8ch mode
6875  */
6876 static struct hda_verb alc883_sixstack_ch8_init[] = {
6877         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6878         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6879         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6880         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6881         { } /* end */
6882 };
6883
6884 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6885         { 6, alc883_sixstack_ch6_init },
6886         { 8, alc883_sixstack_ch8_init },
6887 };
6888
6889
6890 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6891  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6892  */
6893 static struct snd_kcontrol_new alc882_base_mixer[] = {
6894         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6895         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6896         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6897         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6898         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
6899         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
6900         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
6901         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
6902         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
6903         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
6904         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6905         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6906         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6907         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6908         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6909         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6910         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6911         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6912         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6913         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6914         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6915         { } /* end */
6916 };
6917
6918 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
6919         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6920         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6921         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
6922         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6923         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6924         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6925         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
6926         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
6927         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
6928         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
6929         { } /* end */
6930 };
6931
6932 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
6933         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
6934         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
6935         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
6936         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
6937         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
6938         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
6939         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
6940         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
6941         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6942         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6943         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
6944         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
6945         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
6946         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
6947         { } /* end */
6948 };
6949
6950 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
6951         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6952         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6953         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6954         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6955         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6956         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6957         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6958         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6959         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6960         { } /* end */
6961 };
6962
6963 static struct snd_kcontrol_new alc882_targa_mixer[] = {
6964         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6965         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6966         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
6967         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6968         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6969         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6970         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6971         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6972         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6973         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6974         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
6975         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
6976         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
6977         { } /* end */
6978 };
6979
6980 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
6981  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
6982  */
6983 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
6984         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6985         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
6986         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
6987         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
6988         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
6989         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
6990         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
6991         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
6992         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
6993         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
6994         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
6995         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
6996         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
6997         { } /* end */
6998 };
6999
7000 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7001         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7002         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7003         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7004         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7005         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7006         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7007         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7008         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7009         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7010         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7011         { } /* end */
7012 };
7013
7014 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7015         {
7016                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7017                 .name = "Channel Mode",
7018                 .info = alc_ch_mode_info,
7019                 .get = alc_ch_mode_get,
7020                 .put = alc_ch_mode_put,
7021         },
7022         { } /* end */
7023 };
7024
7025 static struct hda_verb alc882_base_init_verbs[] = {
7026         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7027         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7028         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7029         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7030         /* Rear mixer */
7031         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7032         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7033         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7034         /* CLFE mixer */
7035         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7036         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7037         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7038         /* Side mixer */
7039         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7040         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7041         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7042
7043         /* mute analog input loopbacks */
7044         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7045         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7046         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7047         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7049
7050         /* Front Pin: output 0 (0x0c) */
7051         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7052         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7053         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7054         /* Rear Pin: output 1 (0x0d) */
7055         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7056         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7057         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7058         /* CLFE Pin: output 2 (0x0e) */
7059         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7060         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7061         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7062         /* Side Pin: output 3 (0x0f) */
7063         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7064         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7065         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7066         /* Mic (rear) pin: input vref at 80% */
7067         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7068         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7069         /* Front Mic pin: input vref at 80% */
7070         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7071         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7072         /* Line In pin: input */
7073         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7074         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7075         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7076         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7077         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7078         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7079         /* CD pin widget for input */
7080         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7081
7082         /* FIXME: use matrix-type input source selection */
7083         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7084         /* Input mixer2 */
7085         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7086         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7087         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7088         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7089         /* Input mixer3 */
7090         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7091         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7092         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7093         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7094         /* ADC2: mute amp left and right */
7095         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7096         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7097         /* ADC3: mute amp left and right */
7098         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7099         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7100
7101         { }
7102 };
7103
7104 static struct hda_verb alc882_adc1_init_verbs[] = {
7105         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7106         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7107         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7108         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7109         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7110         /* ADC1: mute amp left and right */
7111         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7112         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7113         { }
7114 };
7115
7116 static struct hda_verb alc882_eapd_verbs[] = {
7117         /* change to EAPD mode */
7118         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7119         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7120         { }
7121 };
7122
7123 static struct hda_verb alc889_eapd_verbs[] = {
7124         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7125         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7126         { }
7127 };
7128
7129 static struct hda_verb alc_hp15_unsol_verbs[] = {
7130         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7131         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7132         {}
7133 };
7134
7135 static struct hda_verb alc885_init_verbs[] = {
7136         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7137         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7138         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7139         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7140         /* Rear mixer */
7141         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7142         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7143         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7144         /* CLFE mixer */
7145         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7146         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7147         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7148         /* Side mixer */
7149         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7150         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7151         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7152
7153         /* mute analog input loopbacks */
7154         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7155         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7156         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7157
7158         /* Front HP Pin: output 0 (0x0c) */
7159         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7160         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7161         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7162         /* Front Pin: output 0 (0x0c) */
7163         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7164         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7165         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7166         /* Rear Pin: output 1 (0x0d) */
7167         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7168         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7169         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7170         /* CLFE Pin: output 2 (0x0e) */
7171         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7172         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7173         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7174         /* Side Pin: output 3 (0x0f) */
7175         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7176         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7177         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7178         /* Mic (rear) pin: input vref at 80% */
7179         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7180         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7181         /* Front Mic pin: input vref at 80% */
7182         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7183         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7184         /* Line In pin: input */
7185         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7186         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7187
7188         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7189         /* Input mixer1 */
7190         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7191         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7192         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7193         /* Input mixer2 */
7194         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7195         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7196         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7197         /* Input mixer3 */
7198         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7199         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7200         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7201         /* ADC2: mute amp left and right */
7202         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7203         /* ADC3: mute amp left and right */
7204         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7205
7206         { }
7207 };
7208
7209 static struct hda_verb alc885_init_input_verbs[] = {
7210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7212         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7213         { }
7214 };
7215
7216
7217 /* Unmute Selector 24h and set the default input to front mic */
7218 static struct hda_verb alc889_init_input_verbs[] = {
7219         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7220         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7221         { }
7222 };
7223
7224
7225 #define alc883_init_verbs       alc882_base_init_verbs
7226
7227 /* Mac Pro test */
7228 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7229         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7230         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7231         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7232         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7233         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7234         /* FIXME: this looks suspicious...
7235         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
7236         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
7237         */
7238         { } /* end */
7239 };
7240
7241 static struct hda_verb alc882_macpro_init_verbs[] = {
7242         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7243         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7244         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7245         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7246         /* Front Pin: output 0 (0x0c) */
7247         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7248         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7249         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7250         /* Front Mic pin: input vref at 80% */
7251         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7252         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7253         /* Speaker:  output */
7254         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7255         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7256         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7257         /* Headphone output (output 0 - 0x0c) */
7258         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7259         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7260         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7261
7262         /* FIXME: use matrix-type input source selection */
7263         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7264         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7265         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7266         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7267         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7268         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7269         /* Input mixer2 */
7270         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7271         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7272         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7273         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7274         /* Input mixer3 */
7275         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7276         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7277         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7278         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7279         /* ADC1: mute amp left and right */
7280         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7281         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7282         /* ADC2: mute amp left and right */
7283         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7284         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7285         /* ADC3: mute amp left and right */
7286         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7287         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7288
7289         { }
7290 };
7291
7292 /* Macbook 5,1 */
7293 static struct hda_verb alc885_mb5_init_verbs[] = {
7294         /* DACs */
7295         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7296         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7297         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7298         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7299         /* Front mixer */
7300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7301         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7302         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7303         /* Surround mixer */
7304         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7305         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7306         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7307         /* LFE mixer */
7308         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7309         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7310         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7311         /* HP mixer */
7312         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7313         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7314         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7315         /* Front Pin (0x0c) */
7316         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7317         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7318         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7319         /* LFE Pin (0x0e) */
7320         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7321         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7322         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7323         /* HP Pin (0x0f) */
7324         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7325         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7326         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7327         /* Front Mic pin: input vref at 80% */
7328         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7329         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7330         /* Line In pin */
7331         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7332         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7333
7334         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7335         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7336         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7337         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7338         { }
7339 };
7340
7341 /* Macbook Pro rev3 */
7342 static struct hda_verb alc885_mbp3_init_verbs[] = {
7343         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7344         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7347         /* Rear mixer */
7348         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7349         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7350         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7351         /* Front Pin: output 0 (0x0c) */
7352         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7353         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7354         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7355         /* HP Pin: output 0 (0x0d) */
7356         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7357         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7358         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7359         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7360         /* Mic (rear) pin: input vref at 80% */
7361         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7362         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7363         /* Front Mic pin: input vref at 80% */
7364         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7365         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7366         /* Line In pin: use output 1 when in LineOut mode */
7367         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7368         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7369         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7370
7371         /* FIXME: use matrix-type input source selection */
7372         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7373         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7374         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7375         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7376         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7377         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7378         /* Input mixer2 */
7379         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7380         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7381         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7382         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7383         /* Input mixer3 */
7384         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7385         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7386         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7387         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7388         /* ADC1: mute amp left and right */
7389         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7390         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7391         /* ADC2: mute amp left and right */
7392         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7393         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7394         /* ADC3: mute amp left and right */
7395         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7396         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7397
7398         { }
7399 };
7400
7401 /* iMac 24 mixer. */
7402 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7403         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7404         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7405         { } /* end */
7406 };
7407
7408 /* iMac 24 init verbs. */
7409 static struct hda_verb alc885_imac24_init_verbs[] = {
7410         /* Internal speakers: output 0 (0x0c) */
7411         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7412         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7413         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7414         /* Internal speakers: output 0 (0x0c) */
7415         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7416         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7417         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7418         /* Headphone: output 0 (0x0c) */
7419         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7420         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7421         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7422         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7423         /* Front Mic: input vref at 80% */
7424         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7425         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7426         { }
7427 };
7428
7429 /* Toggle speaker-output according to the hp-jack state */
7430 static void alc885_imac24_automute_init_hook(struct hda_codec *codec)
7431 {
7432         struct alc_spec *spec = codec->spec;
7433
7434         spec->autocfg.hp_pins[0] = 0x14;
7435         spec->autocfg.speaker_pins[0] = 0x18;
7436         spec->autocfg.speaker_pins[1] = 0x1a;
7437         alc_automute_amp(codec);
7438 }
7439
7440 static void alc885_mbp3_init_hook(struct hda_codec *codec)
7441 {
7442         struct alc_spec *spec = codec->spec;
7443
7444         spec->autocfg.hp_pins[0] = 0x15;
7445         spec->autocfg.speaker_pins[0] = 0x14;
7446         alc_automute_amp(codec);
7447 }
7448
7449
7450 static struct hda_verb alc882_targa_verbs[] = {
7451         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7452         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7453
7454         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7455         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7456
7457         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7458         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7459         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7460
7461         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7462         { } /* end */
7463 };
7464
7465 /* toggle speaker-output according to the hp-jack state */
7466 static void alc882_targa_automute(struct hda_codec *codec)
7467 {
7468         struct alc_spec *spec = codec->spec;
7469         alc_automute_amp(codec);
7470         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7471                                   spec->jack_present ? 1 : 3);
7472 }
7473
7474 static void alc882_targa_init_hook(struct hda_codec *codec)
7475 {
7476         struct alc_spec *spec = codec->spec;
7477
7478         spec->autocfg.hp_pins[0] = 0x14;
7479         spec->autocfg.speaker_pins[0] = 0x1b;
7480         alc882_targa_automute(codec);
7481 }
7482
7483 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7484 {
7485         if ((res >> 26) == ALC880_HP_EVENT)
7486                 alc882_targa_automute(codec);
7487 }
7488
7489 static struct hda_verb alc882_asus_a7j_verbs[] = {
7490         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7491         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7492
7493         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7494         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7495         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7496
7497         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7498         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7499         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7500
7501         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7502         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7503         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7504         { } /* end */
7505 };
7506
7507 static struct hda_verb alc882_asus_a7m_verbs[] = {
7508         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7509         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7510
7511         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7512         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7513         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7514
7515         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7516         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7517         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7518
7519         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7520         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7521         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7522         { } /* end */
7523 };
7524
7525 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7526 {
7527         unsigned int gpiostate, gpiomask, gpiodir;
7528
7529         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7530                                        AC_VERB_GET_GPIO_DATA, 0);
7531
7532         if (!muted)
7533                 gpiostate |= (1 << pin);
7534         else
7535                 gpiostate &= ~(1 << pin);
7536
7537         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7538                                       AC_VERB_GET_GPIO_MASK, 0);
7539         gpiomask |= (1 << pin);
7540
7541         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7542                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7543         gpiodir |= (1 << pin);
7544
7545
7546         snd_hda_codec_write(codec, codec->afg, 0,
7547                             AC_VERB_SET_GPIO_MASK, gpiomask);
7548         snd_hda_codec_write(codec, codec->afg, 0,
7549                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7550
7551         msleep(1);
7552
7553         snd_hda_codec_write(codec, codec->afg, 0,
7554                             AC_VERB_SET_GPIO_DATA, gpiostate);
7555 }
7556
7557 /* set up GPIO at initialization */
7558 static void alc885_macpro_init_hook(struct hda_codec *codec)
7559 {
7560         alc882_gpio_mute(codec, 0, 0);
7561         alc882_gpio_mute(codec, 1, 0);
7562 }
7563
7564 /* set up GPIO and update auto-muting at initialization */
7565 static void alc885_imac24_init_hook(struct hda_codec *codec)
7566 {
7567         alc885_macpro_init_hook(codec);
7568         alc885_imac24_automute_init_hook(codec);
7569 }
7570
7571 /*
7572  * generic initialization of ADC, input mixers and output mixers
7573  */
7574 static struct hda_verb alc883_auto_init_verbs[] = {
7575         /*
7576          * Unmute ADC0-2 and set the default input to mic-in
7577          */
7578         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7579         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7580         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7581         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7582
7583         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7584          * mixer widget
7585          * Note: PASD motherboards uses the Line In 2 as the input for
7586          * front panel mic (mic 2)
7587          */
7588         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7589         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7590         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7591         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7592         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7593         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7594
7595         /*
7596          * Set up output mixers (0x0c - 0x0f)
7597          */
7598         /* set vol=0 to output mixers */
7599         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7600         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7601         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7602         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7603         /* set up input amps for analog loopback */
7604         /* Amp Indices: DAC = 0, mixer = 1 */
7605         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7606         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7607         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7608         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7609         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7610         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7611         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7612         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7613         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7614         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7615
7616         /* FIXME: use matrix-type input source selection */
7617         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7618         /* Input mixer2 */
7619         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7620         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7621         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7622         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7623         /* Input mixer3 */
7624         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7625         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7626         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7627         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7628
7629         { }
7630 };
7631
7632 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7633 static struct hda_verb alc889A_mb31_ch2_init[] = {
7634         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7635         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7636         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7637         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7638         { } /* end */
7639 };
7640
7641 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7642 static struct hda_verb alc889A_mb31_ch4_init[] = {
7643         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7644         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7645         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7646         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7647         { } /* end */
7648 };
7649
7650 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7651 static struct hda_verb alc889A_mb31_ch5_init[] = {
7652         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7653         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7654         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7655         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7656         { } /* end */
7657 };
7658
7659 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7660 static struct hda_verb alc889A_mb31_ch6_init[] = {
7661         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7662         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7663         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7664         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7665         { } /* end */
7666 };
7667
7668 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7669         { 2, alc889A_mb31_ch2_init },
7670         { 4, alc889A_mb31_ch4_init },
7671         { 5, alc889A_mb31_ch5_init },
7672         { 6, alc889A_mb31_ch6_init },
7673 };
7674
7675 static struct hda_verb alc883_medion_eapd_verbs[] = {
7676         /* eanable EAPD on medion laptop */
7677         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7678         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7679         { }
7680 };
7681
7682 #define alc883_base_mixer       alc882_base_mixer
7683
7684 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7685         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7686         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7687         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7688         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7689         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7690         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7691         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7692         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7693         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7694         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7695         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7696         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7697         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7698         { } /* end */
7699 };
7700
7701 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7702         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7703         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7704         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7705         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7706         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7707         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7708         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7709         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7710         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7711         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7712         { } /* end */
7713 };
7714
7715 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7716         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7717         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7718         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7719         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7721         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7722         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7723         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7724         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7725         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7726         { } /* end */
7727 };
7728
7729 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7730         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7731         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7732         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7733         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7734         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7735         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7736         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7737         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7738         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7739         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7740         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7741         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7742         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7743         { } /* end */
7744 };
7745
7746 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7747         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7748         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7749         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7750         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7751         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7752         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7753         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7754         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7755         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7756         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7757         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7758         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7759         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7761         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7762         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7763         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7764         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7765         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7766         { } /* end */
7767 };
7768
7769 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7770         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7771         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7772         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7773         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7774         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7775                               HDA_OUTPUT),
7776         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7777         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7778         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7779         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7780         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7781         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7782         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7783         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7784         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7785         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7787         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7788         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7789         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7790         { } /* end */
7791 };
7792
7793 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
7794         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7795         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7796         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7797         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7798         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7799                               HDA_OUTPUT),
7800         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7801         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7802         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7803         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7804         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
7805         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7806         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7807         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7808         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
7809         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
7810         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
7811         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7812         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7813         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7814         { } /* end */
7815 };
7816
7817 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7818         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7819         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7820         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7821         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7822         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7823         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7824         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7825         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7826         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7827         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7828         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7829         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7830         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7831         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7832         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7833         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7834         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7835         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7836         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7837         { } /* end */
7838 };
7839
7840 static struct snd_kcontrol_new alc883_targa_mixer[] = {
7841         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7842         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7843         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7844         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7845         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7846         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7847         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7848         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7849         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7850         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7851         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7852         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7853         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7854         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7855         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7856         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7857         { } /* end */
7858 };
7859
7860 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
7861         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7862         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7863         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7864         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7865         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7866         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7867         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7868         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7869         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7870         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7871         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7872         { } /* end */
7873 };
7874
7875 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7876         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7877         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7878         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7879         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7880         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7881         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7882         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7883         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7884         { } /* end */
7885 };
7886
7887 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
7888         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7889         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
7890         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7891         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7892         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7893         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7894         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7895         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7896         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7897         { } /* end */
7898 };
7899
7900 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
7901         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7902         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7903         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7904         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7905         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7906         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7907         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7908         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7909         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7910         { } /* end */
7911 };
7912
7913 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
7914         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7915         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7916         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7917         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7918         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7919         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7920         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7921         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7922         { } /* end */
7923 };
7924
7925 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
7926         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7927         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7928         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7929         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
7930         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7931         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7932         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7933         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7934         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7935         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7937         { } /* end */
7938 };
7939
7940 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
7941         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7942         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7943         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
7944         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
7945         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
7946                                                 0x0d, 1, 0x0, HDA_OUTPUT),
7947         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
7948         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
7949         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
7950         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7951         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7952         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7953         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7954         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7955         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7956         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7957         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7958         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7959         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7960         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7961         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7962         { } /* end */
7963 };
7964
7965 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
7966         /* Output mixers */
7967         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7968         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7969         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7970         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7971         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
7972                 HDA_OUTPUT),
7973         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
7974         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
7975         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
7976         /* Output switches */
7977         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
7978         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
7979         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
7980         /* Boost mixers */
7981         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7982         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7983         /* Input mixers */
7984         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7985         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7986         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7987         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7988         { } /* end */
7989 };
7990
7991 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
7992         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7993         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7994         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7996         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7997         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7998         { } /* end */
7999 };
8000
8001 static struct hda_bind_ctls alc883_bind_cap_vol = {
8002         .ops = &snd_hda_bind_vol,
8003         .values = {
8004                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8005                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8006                 0
8007         },
8008 };
8009
8010 static struct hda_bind_ctls alc883_bind_cap_switch = {
8011         .ops = &snd_hda_bind_sw,
8012         .values = {
8013                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8014                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8015                 0
8016         },
8017 };
8018
8019 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8020         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8021         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8022         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8023         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8024         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8025         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8026         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8027         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8028         { } /* end */
8029 };
8030
8031 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8032         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8033         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8034         {
8035                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8036                 /* .name = "Capture Source", */
8037                 .name = "Input Source",
8038                 .count = 1,
8039                 .info = alc_mux_enum_info,
8040                 .get = alc_mux_enum_get,
8041                 .put = alc_mux_enum_put,
8042         },
8043         { } /* end */
8044 };
8045
8046 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8047         {
8048                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8049                 .name = "Channel Mode",
8050                 .info = alc_ch_mode_info,
8051                 .get = alc_ch_mode_get,
8052                 .put = alc_ch_mode_put,
8053         },
8054         { } /* end */
8055 };
8056
8057 /* toggle speaker-output according to the hp-jack state */
8058 static void alc883_mitac_init_hook(struct hda_codec *codec)
8059 {
8060         struct alc_spec *spec = codec->spec;
8061
8062         spec->autocfg.hp_pins[0] = 0x15;
8063         spec->autocfg.speaker_pins[0] = 0x14;
8064         spec->autocfg.speaker_pins[1] = 0x17;
8065         alc_automute_amp(codec);
8066 }
8067
8068 /* auto-toggle front mic */
8069 /*
8070 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8071 {
8072         unsigned int present;
8073         unsigned char bits;
8074
8075         present = snd_hda_codec_read(codec, 0x18, 0,
8076                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8077         bits = present ? HDA_AMP_MUTE : 0;
8078         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8079 }
8080 */
8081
8082 static struct hda_verb alc883_mitac_verbs[] = {
8083         /* HP */
8084         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8085         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8086         /* Subwoofer */
8087         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8088         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8089
8090         /* enable unsolicited event */
8091         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8092         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8093
8094         { } /* end */
8095 };
8096
8097 static struct hda_verb alc883_clevo_m720_verbs[] = {
8098         /* HP */
8099         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8100         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8101         /* Int speaker */
8102         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8103         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8104
8105         /* enable unsolicited event */
8106         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8107         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8108
8109         { } /* end */
8110 };
8111
8112 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8113         /* HP */
8114         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8115         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8116         /* Subwoofer */
8117         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8118         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8119
8120         /* enable unsolicited event */
8121         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8122
8123         { } /* end */
8124 };
8125
8126 static struct hda_verb alc883_targa_verbs[] = {
8127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8128         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8129
8130         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8131         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8132
8133 /* Connect Line-Out side jack (SPDIF) to Side */
8134         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8135         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8136         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8137 /* Connect Mic jack to CLFE */
8138         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8139         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8140         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8141 /* Connect Line-in jack to Surround */
8142         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8143         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8144         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8145 /* Connect HP out jack to Front */
8146         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8147         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8148         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8149
8150         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8151
8152         { } /* end */
8153 };
8154
8155 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8156         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8157         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8158         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8159         { } /* end */
8160 };
8161
8162 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8163         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8164         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8165         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8166         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8167         { } /* end */
8168 };
8169
8170 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8171         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8172         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8173         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8174         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8175         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8176         { } /* end */
8177 };
8178
8179 static struct hda_verb alc883_haier_w66_verbs[] = {
8180         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8181         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8182
8183         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8184
8185         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8186         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8187         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8188         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8189         { } /* end */
8190 };
8191
8192 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8193         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8194         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8195         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8196         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8197         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8198         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8199         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8200         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8201         { } /* end */
8202 };
8203
8204 static struct hda_verb alc888_6st_dell_verbs[] = {
8205         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8206         { }
8207 };
8208
8209 static struct hda_verb alc883_vaiott_verbs[] = {
8210         /* HP */
8211         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8212         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8213
8214         /* enable unsolicited event */
8215         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8216
8217         { } /* end */
8218 };
8219
8220 static void alc888_3st_hp_init_hook(struct hda_codec *codec)
8221 {
8222         struct alc_spec *spec = codec->spec;
8223
8224         spec->autocfg.hp_pins[0] = 0x1b;
8225         spec->autocfg.speaker_pins[0] = 0x14;
8226         spec->autocfg.speaker_pins[1] = 0x16;
8227         spec->autocfg.speaker_pins[2] = 0x18;
8228         alc_automute_amp(codec);
8229 }
8230
8231 static struct hda_verb alc888_3st_hp_verbs[] = {
8232         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8233         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8234         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8235         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8236         { } /* end */
8237 };
8238
8239 /*
8240  * 2ch mode
8241  */
8242 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8243         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8244         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8245         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8246         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8247         { } /* end */
8248 };
8249
8250 /*
8251  * 4ch mode
8252  */
8253 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8254         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8255         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8256         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8257         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8258         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8259         { } /* end */
8260 };
8261
8262 /*
8263  * 6ch mode
8264  */
8265 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8266         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8267         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8268         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8269         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8270         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8271         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8272         { } /* end */
8273 };
8274
8275 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8276         { 2, alc888_3st_hp_2ch_init },
8277         { 4, alc888_3st_hp_4ch_init },
8278         { 6, alc888_3st_hp_6ch_init },
8279 };
8280
8281 /* toggle front-jack and RCA according to the hp-jack state */
8282 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8283 {
8284         unsigned int present;
8285
8286         present = snd_hda_codec_read(codec, 0x1b, 0,
8287                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8288         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8289                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8290         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8291                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8292 }
8293
8294 /* toggle RCA according to the front-jack state */
8295 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8296 {
8297         unsigned int present;
8298
8299         present = snd_hda_codec_read(codec, 0x14, 0,
8300                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8301         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8302                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8303 }
8304
8305 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8306                                              unsigned int res)
8307 {
8308         if ((res >> 26) == ALC880_HP_EVENT)
8309                 alc888_lenovo_ms7195_front_automute(codec);
8310         if ((res >> 26) == ALC880_FRONT_EVENT)
8311                 alc888_lenovo_ms7195_rca_automute(codec);
8312 }
8313
8314 static struct hda_verb alc883_medion_md2_verbs[] = {
8315         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8316         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8317
8318         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8319
8320         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8321         { } /* end */
8322 };
8323
8324 /* toggle speaker-output according to the hp-jack state */
8325 static void alc883_medion_md2_init_hook(struct hda_codec *codec)
8326 {
8327         struct alc_spec *spec = codec->spec;
8328
8329         spec->autocfg.hp_pins[0] = 0x14;
8330         spec->autocfg.speaker_pins[0] = 0x15;
8331         alc_automute_amp(codec);
8332 }
8333
8334 /* toggle speaker-output according to the hp-jack state */
8335 #define alc883_targa_init_hook          alc882_targa_init_hook
8336 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8337
8338 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8339 {
8340         unsigned int present;
8341
8342         present = snd_hda_codec_read(codec, 0x18, 0,
8343                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8344         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8345                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8346 }
8347
8348 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8349 {
8350         struct alc_spec *spec = codec->spec;
8351
8352         spec->autocfg.hp_pins[0] = 0x15;
8353         spec->autocfg.speaker_pins[0] = 0x14;
8354         alc_automute_amp(codec);
8355         alc883_clevo_m720_mic_automute(codec);
8356 }
8357
8358 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8359                                            unsigned int res)
8360 {
8361         switch (res >> 26) {
8362         case ALC880_MIC_EVENT:
8363                 alc883_clevo_m720_mic_automute(codec);
8364                 break;
8365         default:
8366                 alc_automute_amp_unsol_event(codec, res);
8367                 break;
8368         }
8369 }
8370
8371 /* toggle speaker-output according to the hp-jack state */
8372 static void alc883_2ch_fujitsu_pi2515_init_hook(struct hda_codec *codec)
8373 {
8374         struct alc_spec *spec = codec->spec;
8375
8376         spec->autocfg.hp_pins[0] = 0x14;
8377         spec->autocfg.speaker_pins[0] = 0x15;
8378         alc_automute_amp(codec);
8379 }
8380
8381 static void alc883_haier_w66_init_hook(struct hda_codec *codec)
8382 {
8383         struct alc_spec *spec = codec->spec;
8384
8385         spec->autocfg.hp_pins[0] = 0x1b;
8386         spec->autocfg.speaker_pins[0] = 0x14;
8387         alc_automute_amp(codec);
8388 }
8389
8390 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8391 {
8392         unsigned int present;
8393         unsigned char bits;
8394
8395         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8396                 & AC_PINSENSE_PRESENCE;
8397         bits = present ? HDA_AMP_MUTE : 0;
8398         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8399                                  HDA_AMP_MUTE, bits);
8400 }
8401
8402 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8403 {
8404         unsigned int present;
8405         unsigned char bits;
8406
8407         present = snd_hda_codec_read(codec, 0x1b, 0,
8408                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8409         bits = present ? HDA_AMP_MUTE : 0;
8410         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8411                                  HDA_AMP_MUTE, bits);
8412         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8413                                  HDA_AMP_MUTE, bits);
8414 }
8415
8416 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8417                                            unsigned int res)
8418 {
8419         if ((res >> 26) == ALC880_HP_EVENT)
8420                 alc883_lenovo_101e_all_automute(codec);
8421         if ((res >> 26) == ALC880_FRONT_EVENT)
8422                 alc883_lenovo_101e_ispeaker_automute(codec);
8423 }
8424
8425 /* toggle speaker-output according to the hp-jack state */
8426 static void alc883_acer_aspire_init_hook(struct hda_codec *codec)
8427 {
8428         struct alc_spec *spec = codec->spec;
8429
8430         spec->autocfg.hp_pins[0] = 0x14;
8431         spec->autocfg.speaker_pins[0] = 0x15;
8432         spec->autocfg.speaker_pins[1] = 0x16;
8433         alc_automute_amp(codec);
8434 }
8435
8436 static struct hda_verb alc883_acer_eapd_verbs[] = {
8437         /* HP Pin: output 0 (0x0c) */
8438         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8439         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8440         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8441         /* Front Pin: output 0 (0x0c) */
8442         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8443         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8444         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8445         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8446         /* eanable EAPD on medion laptop */
8447         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8448         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8449         /* enable unsolicited event */
8450         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8451         { }
8452 };
8453
8454 static void alc888_6st_dell_init_hook(struct hda_codec *codec)
8455 {
8456         struct alc_spec *spec = codec->spec;
8457
8458         spec->autocfg.hp_pins[0] = 0x1b;
8459         spec->autocfg.speaker_pins[0] = 0x14;
8460         spec->autocfg.speaker_pins[1] = 0x15;
8461         spec->autocfg.speaker_pins[2] = 0x16;
8462         spec->autocfg.speaker_pins[3] = 0x17;
8463         alc_automute_amp(codec);
8464 }
8465
8466 static void alc888_lenovo_sky_init_hook(struct hda_codec *codec)
8467 {
8468         struct alc_spec *spec = codec->spec;
8469
8470         spec->autocfg.hp_pins[0] = 0x1b;
8471         spec->autocfg.speaker_pins[0] = 0x14;
8472         spec->autocfg.speaker_pins[1] = 0x15;
8473         spec->autocfg.speaker_pins[2] = 0x16;
8474         spec->autocfg.speaker_pins[3] = 0x17;
8475         spec->autocfg.speaker_pins[4] = 0x1a;
8476         alc_automute_amp(codec);
8477 }
8478
8479 static void alc883_vaiott_init_hook(struct hda_codec *codec)
8480 {
8481         struct alc_spec *spec = codec->spec;
8482
8483         spec->autocfg.hp_pins[0] = 0x15;
8484         spec->autocfg.speaker_pins[0] = 0x14;
8485         spec->autocfg.speaker_pins[1] = 0x17;
8486         alc_automute_amp(codec);
8487 }
8488
8489 static struct hda_verb alc888_asus_m90v_verbs[] = {
8490         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8491         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8492         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8493         /* enable unsolicited event */
8494         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8495         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8496         { } /* end */
8497 };
8498
8499 static void alc883_nb_mic_automute(struct hda_codec *codec)
8500 {
8501         unsigned int present;
8502
8503         present = snd_hda_codec_read(codec, 0x18, 0,
8504                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8505         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8506                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
8507         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
8508                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
8509 }
8510
8511 static void alc883_M90V_init_hook(struct hda_codec *codec)
8512 {
8513         struct alc_spec *spec = codec->spec;
8514
8515         spec->autocfg.hp_pins[0] = 0x1b;
8516         spec->autocfg.speaker_pins[0] = 0x14;
8517         spec->autocfg.speaker_pins[1] = 0x15;
8518         spec->autocfg.speaker_pins[2] = 0x16;
8519         alc_automute_pin(codec);
8520 }
8521
8522 static void alc883_mode2_unsol_event(struct hda_codec *codec,
8523                                            unsigned int res)
8524 {
8525         switch (res >> 26) {
8526         case ALC880_MIC_EVENT:
8527                 alc883_nb_mic_automute(codec);
8528                 break;
8529         default:
8530                 alc_sku_unsol_event(codec, res);
8531                 break;
8532         }
8533 }
8534
8535 static void alc883_mode2_inithook(struct hda_codec *codec)
8536 {
8537         alc883_M90V_init_hook(codec);
8538         alc883_nb_mic_automute(codec);
8539 }
8540
8541 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8542         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8543         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8544         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8545         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8546         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8547         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8548         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8549         /* enable unsolicited event */
8550         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8551         { } /* end */
8552 };
8553
8554 static void alc883_eee1601_inithook(struct hda_codec *codec)
8555 {
8556         struct alc_spec *spec = codec->spec;
8557
8558         spec->autocfg.hp_pins[0] = 0x14;
8559         spec->autocfg.speaker_pins[0] = 0x1b;
8560         alc_automute_pin(codec);
8561 }
8562
8563 static struct hda_verb alc889A_mb31_verbs[] = {
8564         /* Init rear pin (used as headphone output) */
8565         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8566         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8567         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8568         /* Init line pin (used as output in 4ch and 6ch mode) */
8569         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8570         /* Init line 2 pin (used as headphone out by default) */
8571         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8572         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8573         { } /* end */
8574 };
8575
8576 /* Mute speakers according to the headphone jack state */
8577 static void alc889A_mb31_automute(struct hda_codec *codec)
8578 {
8579         unsigned int present;
8580
8581         /* Mute only in 2ch or 4ch mode */
8582         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8583             == 0x00) {
8584                 present = snd_hda_codec_read(codec, 0x15, 0,
8585                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8586                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8587                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8588                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8589                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8590         }
8591 }
8592
8593 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8594 {
8595         if ((res >> 26) == ALC880_HP_EVENT)
8596                 alc889A_mb31_automute(codec);
8597 }
8598
8599
8600 #ifdef CONFIG_SND_HDA_POWER_SAVE
8601 #define alc882_loopbacks        alc880_loopbacks
8602 #endif
8603
8604 /* pcm configuration: identical with ALC880 */
8605 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8606 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8607 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8608 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8609
8610 static hda_nid_t alc883_slave_dig_outs[] = {
8611         ALC1200_DIGOUT_NID, 0,
8612 };
8613
8614 static hda_nid_t alc1200_slave_dig_outs[] = {
8615         ALC883_DIGOUT_NID, 0,
8616 };
8617
8618 /*
8619  * configuration and preset
8620  */
8621 static const char *alc882_models[ALC882_MODEL_LAST] = {
8622         [ALC882_3ST_DIG]        = "3stack-dig",
8623         [ALC882_6ST_DIG]        = "6stack-dig",
8624         [ALC882_ARIMA]          = "arima",
8625         [ALC882_W2JC]           = "w2jc",
8626         [ALC882_TARGA]          = "targa",
8627         [ALC882_ASUS_A7J]       = "asus-a7j",
8628         [ALC882_ASUS_A7M]       = "asus-a7m",
8629         [ALC885_MACPRO]         = "macpro",
8630         [ALC885_MB5]            = "mb5",
8631         [ALC885_MBP3]           = "mbp3",
8632         [ALC885_IMAC24]         = "imac24",
8633         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8634         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8635         [ALC883_3ST_6ch]        = "3stack-6ch",
8636         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8637         [ALC883_TARGA_DIG]      = "targa-dig",
8638         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8639         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8640         [ALC883_ACER]           = "acer",
8641         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8642         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8643         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8644         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8645         [ALC883_MEDION]         = "medion",
8646         [ALC883_MEDION_MD2]     = "medion-md2",
8647         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8648         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8649         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8650         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8651         [ALC888_LENOVO_SKY] = "lenovo-sky",
8652         [ALC883_HAIER_W66]      = "haier-w66",
8653         [ALC888_3ST_HP]         = "3stack-hp",
8654         [ALC888_6ST_DELL]       = "6stack-dell",
8655         [ALC883_MITAC]          = "mitac",
8656         [ALC883_CLEVO_M720]     = "clevo-m720",
8657         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8658         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8659         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8660         [ALC889A_INTEL]         = "intel-alc889a",
8661         [ALC889_INTEL]          = "intel-x58",
8662         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8663         [ALC889A_MB31]          = "mb31",
8664         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8665         [ALC882_AUTO]           = "auto",
8666 };
8667
8668 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8669         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8670
8671         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8672         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8673         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8674         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8675         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8676         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8677         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8678                 ALC888_ACER_ASPIRE_4930G),
8679         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8680                 ALC888_ACER_ASPIRE_4930G),
8681         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8682                 ALC888_ACER_ASPIRE_8930G),
8683         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8684                 ALC888_ACER_ASPIRE_8930G),
8685         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8686         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8687         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8688                 ALC888_ACER_ASPIRE_6530G),
8689         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8690                 ALC888_ACER_ASPIRE_6530G),
8691         /* default Acer -- disabled as it causes more problems.
8692          *    model=auto should work fine now
8693          */
8694         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8695
8696         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8697
8698         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8699         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8700         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8701         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8702         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8703         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8704
8705         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8706         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8707         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8708         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8709         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8710         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8711         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8712         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8713         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8714         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8715         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8716
8717         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8718         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8719         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8720         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8721         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8722         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8723         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8724         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8725         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8726
8727         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8728         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8729         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8730         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8731         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8732         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8733         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8734         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8735         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8736         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8737         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8738         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8739         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8740         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8741         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8742         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8743         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8744         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8745         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8746         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8747         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8748         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8749         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8750         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8751         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8752         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8753         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8754         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8755         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8756
8757         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8758         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8759         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8760         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8761         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8762         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
8763         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8764         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8765                       ALC883_FUJITSU_PI2515),
8766         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8767                 ALC888_FUJITSU_XA3530),
8768         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8769         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8770         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8771         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8772         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8773         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8774         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8775         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8776         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8777
8778         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8779         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8780         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8781         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
8782         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
8783         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
8784         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8785
8786         {}
8787 };
8788
8789 /* codec SSID table for Intel Mac */
8790 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
8791         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
8792         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
8793         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
8794         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
8795         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
8796         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
8797         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
8798         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
8799         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
8800         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
8801         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
8802         /* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
8803          * no perfect solution yet
8804          */
8805         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
8806         {} /* terminator */
8807 };
8808
8809 static struct alc_config_preset alc882_presets[] = {
8810         [ALC882_3ST_DIG] = {
8811                 .mixers = { alc882_base_mixer },
8812                 .init_verbs = { alc882_base_init_verbs,
8813                                 alc882_adc1_init_verbs },
8814                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8815                 .dac_nids = alc882_dac_nids,
8816                 .dig_out_nid = ALC882_DIGOUT_NID,
8817                 .dig_in_nid = ALC882_DIGIN_NID,
8818                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8819                 .channel_mode = alc882_ch_modes,
8820                 .need_dac_fix = 1,
8821                 .input_mux = &alc882_capture_source,
8822         },
8823         [ALC882_6ST_DIG] = {
8824                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8825                 .init_verbs = { alc882_base_init_verbs,
8826                                 alc882_adc1_init_verbs },
8827                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8828                 .dac_nids = alc882_dac_nids,
8829                 .dig_out_nid = ALC882_DIGOUT_NID,
8830                 .dig_in_nid = ALC882_DIGIN_NID,
8831                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8832                 .channel_mode = alc882_sixstack_modes,
8833                 .input_mux = &alc882_capture_source,
8834         },
8835         [ALC882_ARIMA] = {
8836                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8837                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8838                                 alc882_eapd_verbs },
8839                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8840                 .dac_nids = alc882_dac_nids,
8841                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8842                 .channel_mode = alc882_sixstack_modes,
8843                 .input_mux = &alc882_capture_source,
8844         },
8845         [ALC882_W2JC] = {
8846                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
8847                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8848                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
8849                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8850                 .dac_nids = alc882_dac_nids,
8851                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8852                 .channel_mode = alc880_threestack_modes,
8853                 .need_dac_fix = 1,
8854                 .input_mux = &alc882_capture_source,
8855                 .dig_out_nid = ALC882_DIGOUT_NID,
8856         },
8857         [ALC885_MBP3] = {
8858                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
8859                 .init_verbs = { alc885_mbp3_init_verbs,
8860                                 alc880_gpio1_init_verbs },
8861                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8862                 .dac_nids = alc882_dac_nids,
8863                 .channel_mode = alc885_mbp_6ch_modes,
8864                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_6ch_modes),
8865                 .input_mux = &alc882_capture_source,
8866                 .dig_out_nid = ALC882_DIGOUT_NID,
8867                 .dig_in_nid = ALC882_DIGIN_NID,
8868                 .unsol_event = alc_automute_amp_unsol_event,
8869                 .init_hook = alc885_mbp3_init_hook,
8870         },
8871         [ALC885_MB5] = {
8872                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
8873                 .init_verbs = { alc885_mb5_init_verbs,
8874                                 alc880_gpio1_init_verbs },
8875                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8876                 .dac_nids = alc882_dac_nids,
8877                 .channel_mode = alc885_mb5_6ch_modes,
8878                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
8879                 .input_mux = &mb5_capture_source,
8880                 .dig_out_nid = ALC882_DIGOUT_NID,
8881                 .dig_in_nid = ALC882_DIGIN_NID,
8882         },
8883         [ALC885_MACPRO] = {
8884                 .mixers = { alc882_macpro_mixer },
8885                 .init_verbs = { alc882_macpro_init_verbs },
8886                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8887                 .dac_nids = alc882_dac_nids,
8888                 .dig_out_nid = ALC882_DIGOUT_NID,
8889                 .dig_in_nid = ALC882_DIGIN_NID,
8890                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8891                 .channel_mode = alc882_ch_modes,
8892                 .input_mux = &alc882_capture_source,
8893                 .init_hook = alc885_macpro_init_hook,
8894         },
8895         [ALC885_IMAC24] = {
8896                 .mixers = { alc885_imac24_mixer },
8897                 .init_verbs = { alc885_imac24_init_verbs },
8898                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8899                 .dac_nids = alc882_dac_nids,
8900                 .dig_out_nid = ALC882_DIGOUT_NID,
8901                 .dig_in_nid = ALC882_DIGIN_NID,
8902                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8903                 .channel_mode = alc882_ch_modes,
8904                 .input_mux = &alc882_capture_source,
8905                 .unsol_event = alc_automute_amp_unsol_event,
8906                 .init_hook = alc885_imac24_init_hook,
8907         },
8908         [ALC882_TARGA] = {
8909                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
8910                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8911                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
8912                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8913                 .dac_nids = alc882_dac_nids,
8914                 .dig_out_nid = ALC882_DIGOUT_NID,
8915                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8916                 .adc_nids = alc882_adc_nids,
8917                 .capsrc_nids = alc882_capsrc_nids,
8918                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8919                 .channel_mode = alc882_3ST_6ch_modes,
8920                 .need_dac_fix = 1,
8921                 .input_mux = &alc882_capture_source,
8922                 .unsol_event = alc882_targa_unsol_event,
8923                 .init_hook = alc882_targa_init_hook,
8924         },
8925         [ALC882_ASUS_A7J] = {
8926                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
8927                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8928                                 alc882_asus_a7j_verbs},
8929                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8930                 .dac_nids = alc882_dac_nids,
8931                 .dig_out_nid = ALC882_DIGOUT_NID,
8932                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
8933                 .adc_nids = alc882_adc_nids,
8934                 .capsrc_nids = alc882_capsrc_nids,
8935                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
8936                 .channel_mode = alc882_3ST_6ch_modes,
8937                 .need_dac_fix = 1,
8938                 .input_mux = &alc882_capture_source,
8939         },
8940         [ALC882_ASUS_A7M] = {
8941                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
8942                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8943                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
8944                                 alc882_asus_a7m_verbs },
8945                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8946                 .dac_nids = alc882_dac_nids,
8947                 .dig_out_nid = ALC882_DIGOUT_NID,
8948                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8949                 .channel_mode = alc880_threestack_modes,
8950                 .need_dac_fix = 1,
8951                 .input_mux = &alc882_capture_source,
8952         },
8953         [ALC883_3ST_2ch_DIG] = {
8954                 .mixers = { alc883_3ST_2ch_mixer },
8955                 .init_verbs = { alc883_init_verbs },
8956                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8957                 .dac_nids = alc883_dac_nids,
8958                 .dig_out_nid = ALC883_DIGOUT_NID,
8959                 .dig_in_nid = ALC883_DIGIN_NID,
8960                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
8961                 .channel_mode = alc883_3ST_2ch_modes,
8962                 .input_mux = &alc883_capture_source,
8963         },
8964         [ALC883_3ST_6ch_DIG] = {
8965                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8966                 .init_verbs = { alc883_init_verbs },
8967                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8968                 .dac_nids = alc883_dac_nids,
8969                 .dig_out_nid = ALC883_DIGOUT_NID,
8970                 .dig_in_nid = ALC883_DIGIN_NID,
8971                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8972                 .channel_mode = alc883_3ST_6ch_modes,
8973                 .need_dac_fix = 1,
8974                 .input_mux = &alc883_capture_source,
8975         },
8976         [ALC883_3ST_6ch] = {
8977                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
8978                 .init_verbs = { alc883_init_verbs },
8979                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8980                 .dac_nids = alc883_dac_nids,
8981                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
8982                 .channel_mode = alc883_3ST_6ch_modes,
8983                 .need_dac_fix = 1,
8984                 .input_mux = &alc883_capture_source,
8985         },
8986         [ALC883_3ST_6ch_INTEL] = {
8987                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
8988                 .init_verbs = { alc883_init_verbs },
8989                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
8990                 .dac_nids = alc883_dac_nids,
8991                 .dig_out_nid = ALC883_DIGOUT_NID,
8992                 .dig_in_nid = ALC883_DIGIN_NID,
8993                 .slave_dig_outs = alc883_slave_dig_outs,
8994                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
8995                 .channel_mode = alc883_3ST_6ch_intel_modes,
8996                 .need_dac_fix = 1,
8997                 .input_mux = &alc883_3stack_6ch_intel,
8998         },
8999         [ALC889A_INTEL] = {
9000                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9001                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9002                                 alc_hp15_unsol_verbs },
9003                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9004                 .dac_nids = alc883_dac_nids,
9005                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9006                 .adc_nids = alc889_adc_nids,
9007                 .dig_out_nid = ALC883_DIGOUT_NID,
9008                 .dig_in_nid = ALC883_DIGIN_NID,
9009                 .slave_dig_outs = alc883_slave_dig_outs,
9010                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9011                 .channel_mode = alc889_8ch_intel_modes,
9012                 .capsrc_nids = alc889_capsrc_nids,
9013                 .input_mux = &alc889_capture_source,
9014                 .init_hook = alc889_automute_init,
9015                 .unsol_event = alc_automute_amp_unsol_event,
9016                 .need_dac_fix = 1,
9017         },
9018         [ALC889_INTEL] = {
9019                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9020                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9021                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9022                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9023                 .dac_nids = alc883_dac_nids,
9024                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9025                 .adc_nids = alc889_adc_nids,
9026                 .dig_out_nid = ALC883_DIGOUT_NID,
9027                 .dig_in_nid = ALC883_DIGIN_NID,
9028                 .slave_dig_outs = alc883_slave_dig_outs,
9029                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9030                 .channel_mode = alc889_8ch_intel_modes,
9031                 .capsrc_nids = alc889_capsrc_nids,
9032                 .input_mux = &alc889_capture_source,
9033                 .init_hook = alc889_intel_init_hook,
9034                 .unsol_event = alc_automute_amp_unsol_event,
9035                 .need_dac_fix = 1,
9036         },
9037         [ALC883_6ST_DIG] = {
9038                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9039                 .init_verbs = { alc883_init_verbs },
9040                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9041                 .dac_nids = alc883_dac_nids,
9042                 .dig_out_nid = ALC883_DIGOUT_NID,
9043                 .dig_in_nid = ALC883_DIGIN_NID,
9044                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9045                 .channel_mode = alc883_sixstack_modes,
9046                 .input_mux = &alc883_capture_source,
9047         },
9048         [ALC883_TARGA_DIG] = {
9049                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9050                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9051                                 alc883_targa_verbs},
9052                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9053                 .dac_nids = alc883_dac_nids,
9054                 .dig_out_nid = ALC883_DIGOUT_NID,
9055                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9056                 .channel_mode = alc883_3ST_6ch_modes,
9057                 .need_dac_fix = 1,
9058                 .input_mux = &alc883_capture_source,
9059                 .unsol_event = alc883_targa_unsol_event,
9060                 .init_hook = alc883_targa_init_hook,
9061         },
9062         [ALC883_TARGA_2ch_DIG] = {
9063                 .mixers = { alc883_targa_2ch_mixer},
9064                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9065                                 alc883_targa_verbs},
9066                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9067                 .dac_nids = alc883_dac_nids,
9068                 .adc_nids = alc883_adc_nids_alt,
9069                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9070                 .dig_out_nid = ALC883_DIGOUT_NID,
9071                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9072                 .channel_mode = alc883_3ST_2ch_modes,
9073                 .input_mux = &alc883_capture_source,
9074                 .unsol_event = alc883_targa_unsol_event,
9075                 .init_hook = alc883_targa_init_hook,
9076         },
9077         [ALC883_TARGA_8ch_DIG] = {
9078                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9079                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9080                                 alc883_targa_verbs },
9081                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9082                 .dac_nids = alc883_dac_nids,
9083                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9084                 .adc_nids = alc883_adc_nids_rev,
9085                 .capsrc_nids = alc883_capsrc_nids_rev,
9086                 .dig_out_nid = ALC883_DIGOUT_NID,
9087                 .dig_in_nid = ALC883_DIGIN_NID,
9088                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9089                 .channel_mode = alc883_4ST_8ch_modes,
9090                 .need_dac_fix = 1,
9091                 .input_mux = &alc883_capture_source,
9092                 .unsol_event = alc883_targa_unsol_event,
9093                 .init_hook = alc883_targa_init_hook,
9094         },
9095         [ALC883_ACER] = {
9096                 .mixers = { alc883_base_mixer },
9097                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9098                  * and the headphone jack.  Turn this on and rely on the
9099                  * standard mute methods whenever the user wants to turn
9100                  * these outputs off.
9101                  */
9102                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9103                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9104                 .dac_nids = alc883_dac_nids,
9105                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9106                 .channel_mode = alc883_3ST_2ch_modes,
9107                 .input_mux = &alc883_capture_source,
9108         },
9109         [ALC883_ACER_ASPIRE] = {
9110                 .mixers = { alc883_acer_aspire_mixer },
9111                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9112                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9113                 .dac_nids = alc883_dac_nids,
9114                 .dig_out_nid = ALC883_DIGOUT_NID,
9115                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9116                 .channel_mode = alc883_3ST_2ch_modes,
9117                 .input_mux = &alc883_capture_source,
9118                 .unsol_event = alc_automute_amp_unsol_event,
9119                 .init_hook = alc883_acer_aspire_init_hook,
9120         },
9121         [ALC888_ACER_ASPIRE_4930G] = {
9122                 .mixers = { alc888_base_mixer,
9123                                 alc883_chmode_mixer },
9124                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9125                                 alc888_acer_aspire_4930g_verbs },
9126                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9127                 .dac_nids = alc883_dac_nids,
9128                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9129                 .adc_nids = alc883_adc_nids_rev,
9130                 .capsrc_nids = alc883_capsrc_nids_rev,
9131                 .dig_out_nid = ALC883_DIGOUT_NID,
9132                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9133                 .channel_mode = alc883_3ST_6ch_modes,
9134                 .need_dac_fix = 1,
9135                 .num_mux_defs =
9136                         ARRAY_SIZE(alc888_2_capture_sources),
9137                 .input_mux = alc888_2_capture_sources,
9138                 .unsol_event = alc_automute_amp_unsol_event,
9139                 .init_hook = alc888_acer_aspire_4930g_init_hook,
9140         },
9141         [ALC888_ACER_ASPIRE_6530G] = {
9142                 .mixers = { alc888_acer_aspire_6530_mixer },
9143                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9144                                 alc888_acer_aspire_6530g_verbs },
9145                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9146                 .dac_nids = alc883_dac_nids,
9147                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9148                 .adc_nids = alc883_adc_nids_rev,
9149                 .capsrc_nids = alc883_capsrc_nids_rev,
9150                 .dig_out_nid = ALC883_DIGOUT_NID,
9151                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9152                 .channel_mode = alc883_3ST_2ch_modes,
9153                 .num_mux_defs =
9154                         ARRAY_SIZE(alc888_2_capture_sources),
9155                 .input_mux = alc888_acer_aspire_6530_sources,
9156                 .unsol_event = alc_automute_amp_unsol_event,
9157                 .init_hook = alc888_acer_aspire_6530g_init_hook,
9158         },
9159         [ALC888_ACER_ASPIRE_8930G] = {
9160                 .mixers = { alc888_base_mixer,
9161                                 alc883_chmode_mixer },
9162                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9163                                 alc889_acer_aspire_8930g_verbs },
9164                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9165                 .dac_nids = alc883_dac_nids,
9166                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9167                 .adc_nids = alc889_adc_nids,
9168                 .capsrc_nids = alc889_capsrc_nids,
9169                 .dig_out_nid = ALC883_DIGOUT_NID,
9170                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9171                 .channel_mode = alc883_3ST_6ch_modes,
9172                 .need_dac_fix = 1,
9173                 .const_channel_count = 6,
9174                 .num_mux_defs =
9175                         ARRAY_SIZE(alc889_capture_sources),
9176                 .input_mux = alc889_capture_sources,
9177                 .unsol_event = alc_automute_amp_unsol_event,
9178                 .init_hook = alc889_acer_aspire_8930g_init_hook,
9179         },
9180         [ALC883_MEDION] = {
9181                 .mixers = { alc883_fivestack_mixer,
9182                             alc883_chmode_mixer },
9183                 .init_verbs = { alc883_init_verbs,
9184                                 alc883_medion_eapd_verbs },
9185                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9186                 .dac_nids = alc883_dac_nids,
9187                 .adc_nids = alc883_adc_nids_alt,
9188                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9189                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9190                 .channel_mode = alc883_sixstack_modes,
9191                 .input_mux = &alc883_capture_source,
9192         },
9193         [ALC883_MEDION_MD2] = {
9194                 .mixers = { alc883_medion_md2_mixer},
9195                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9196                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9197                 .dac_nids = alc883_dac_nids,
9198                 .dig_out_nid = ALC883_DIGOUT_NID,
9199                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9200                 .channel_mode = alc883_3ST_2ch_modes,
9201                 .input_mux = &alc883_capture_source,
9202                 .unsol_event = alc_automute_amp_unsol_event,
9203                 .init_hook = alc883_medion_md2_init_hook,
9204         },
9205         [ALC883_LAPTOP_EAPD] = {
9206                 .mixers = { alc883_base_mixer },
9207                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9208                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9209                 .dac_nids = alc883_dac_nids,
9210                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9211                 .channel_mode = alc883_3ST_2ch_modes,
9212                 .input_mux = &alc883_capture_source,
9213         },
9214         [ALC883_CLEVO_M720] = {
9215                 .mixers = { alc883_clevo_m720_mixer },
9216                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9217                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9218                 .dac_nids = alc883_dac_nids,
9219                 .dig_out_nid = ALC883_DIGOUT_NID,
9220                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9221                 .channel_mode = alc883_3ST_2ch_modes,
9222                 .input_mux = &alc883_capture_source,
9223                 .unsol_event = alc883_clevo_m720_unsol_event,
9224                 .init_hook = alc883_clevo_m720_init_hook,
9225         },
9226         [ALC883_LENOVO_101E_2ch] = {
9227                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9228                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9229                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9230                 .dac_nids = alc883_dac_nids,
9231                 .adc_nids = alc883_adc_nids_alt,
9232                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9233                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9234                 .channel_mode = alc883_3ST_2ch_modes,
9235                 .input_mux = &alc883_lenovo_101e_capture_source,
9236                 .unsol_event = alc883_lenovo_101e_unsol_event,
9237                 .init_hook = alc883_lenovo_101e_all_automute,
9238         },
9239         [ALC883_LENOVO_NB0763] = {
9240                 .mixers = { alc883_lenovo_nb0763_mixer },
9241                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9242                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9243                 .dac_nids = alc883_dac_nids,
9244                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9245                 .channel_mode = alc883_3ST_2ch_modes,
9246                 .need_dac_fix = 1,
9247                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9248                 .unsol_event = alc_automute_amp_unsol_event,
9249                 .init_hook = alc883_medion_md2_init_hook,
9250         },
9251         [ALC888_LENOVO_MS7195_DIG] = {
9252                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9253                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9254                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9255                 .dac_nids = alc883_dac_nids,
9256                 .dig_out_nid = ALC883_DIGOUT_NID,
9257                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9258                 .channel_mode = alc883_3ST_6ch_modes,
9259                 .need_dac_fix = 1,
9260                 .input_mux = &alc883_capture_source,
9261                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9262                 .init_hook = alc888_lenovo_ms7195_front_automute,
9263         },
9264         [ALC883_HAIER_W66] = {
9265                 .mixers = { alc883_targa_2ch_mixer},
9266                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9267                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9268                 .dac_nids = alc883_dac_nids,
9269                 .dig_out_nid = ALC883_DIGOUT_NID,
9270                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9271                 .channel_mode = alc883_3ST_2ch_modes,
9272                 .input_mux = &alc883_capture_source,
9273                 .unsol_event = alc_automute_amp_unsol_event,
9274                 .init_hook = alc883_haier_w66_init_hook,
9275         },
9276         [ALC888_3ST_HP] = {
9277                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9278                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9279                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9280                 .dac_nids = alc883_dac_nids,
9281                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9282                 .channel_mode = alc888_3st_hp_modes,
9283                 .need_dac_fix = 1,
9284                 .input_mux = &alc883_capture_source,
9285                 .unsol_event = alc_automute_amp_unsol_event,
9286                 .init_hook = alc888_3st_hp_init_hook,
9287         },
9288         [ALC888_6ST_DELL] = {
9289                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9290                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9291                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9292                 .dac_nids = alc883_dac_nids,
9293                 .dig_out_nid = ALC883_DIGOUT_NID,
9294                 .dig_in_nid = ALC883_DIGIN_NID,
9295                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9296                 .channel_mode = alc883_sixstack_modes,
9297                 .input_mux = &alc883_capture_source,
9298                 .unsol_event = alc_automute_amp_unsol_event,
9299                 .init_hook = alc888_6st_dell_init_hook,
9300         },
9301         [ALC883_MITAC] = {
9302                 .mixers = { alc883_mitac_mixer },
9303                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9304                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9305                 .dac_nids = alc883_dac_nids,
9306                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9307                 .channel_mode = alc883_3ST_2ch_modes,
9308                 .input_mux = &alc883_capture_source,
9309                 .unsol_event = alc_automute_amp_unsol_event,
9310                 .init_hook = alc883_mitac_init_hook,
9311         },
9312         [ALC883_FUJITSU_PI2515] = {
9313                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9314                 .init_verbs = { alc883_init_verbs,
9315                                 alc883_2ch_fujitsu_pi2515_verbs},
9316                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9317                 .dac_nids = alc883_dac_nids,
9318                 .dig_out_nid = ALC883_DIGOUT_NID,
9319                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9320                 .channel_mode = alc883_3ST_2ch_modes,
9321                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9322                 .unsol_event = alc_automute_amp_unsol_event,
9323                 .init_hook = alc883_2ch_fujitsu_pi2515_init_hook,
9324         },
9325         [ALC888_FUJITSU_XA3530] = {
9326                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9327                 .init_verbs = { alc883_init_verbs,
9328                         alc888_fujitsu_xa3530_verbs },
9329                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9330                 .dac_nids = alc883_dac_nids,
9331                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9332                 .adc_nids = alc883_adc_nids_rev,
9333                 .capsrc_nids = alc883_capsrc_nids_rev,
9334                 .dig_out_nid = ALC883_DIGOUT_NID,
9335                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9336                 .channel_mode = alc888_4ST_8ch_intel_modes,
9337                 .num_mux_defs =
9338                         ARRAY_SIZE(alc888_2_capture_sources),
9339                 .input_mux = alc888_2_capture_sources,
9340                 .unsol_event = alc_automute_amp_unsol_event,
9341                 .init_hook = alc888_fujitsu_xa3530_init_hook,
9342         },
9343         [ALC888_LENOVO_SKY] = {
9344                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9345                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9346                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9347                 .dac_nids = alc883_dac_nids,
9348                 .dig_out_nid = ALC883_DIGOUT_NID,
9349                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9350                 .channel_mode = alc883_sixstack_modes,
9351                 .need_dac_fix = 1,
9352                 .input_mux = &alc883_lenovo_sky_capture_source,
9353                 .unsol_event = alc_automute_amp_unsol_event,
9354                 .init_hook = alc888_lenovo_sky_init_hook,
9355         },
9356         [ALC888_ASUS_M90V] = {
9357                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9358                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9359                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9360                 .dac_nids = alc883_dac_nids,
9361                 .dig_out_nid = ALC883_DIGOUT_NID,
9362                 .dig_in_nid = ALC883_DIGIN_NID,
9363                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9364                 .channel_mode = alc883_3ST_6ch_modes,
9365                 .need_dac_fix = 1,
9366                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9367                 .unsol_event = alc883_mode2_unsol_event,
9368                 .init_hook = alc883_mode2_inithook,
9369         },
9370         [ALC888_ASUS_EEE1601] = {
9371                 .mixers = { alc883_asus_eee1601_mixer },
9372                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9373                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9374                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9375                 .dac_nids = alc883_dac_nids,
9376                 .dig_out_nid = ALC883_DIGOUT_NID,
9377                 .dig_in_nid = ALC883_DIGIN_NID,
9378                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9379                 .channel_mode = alc883_3ST_2ch_modes,
9380                 .need_dac_fix = 1,
9381                 .input_mux = &alc883_asus_eee1601_capture_source,
9382                 .unsol_event = alc_sku_unsol_event,
9383                 .init_hook = alc883_eee1601_inithook,
9384         },
9385         [ALC1200_ASUS_P5Q] = {
9386                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9387                 .init_verbs = { alc883_init_verbs },
9388                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9389                 .dac_nids = alc883_dac_nids,
9390                 .dig_out_nid = ALC1200_DIGOUT_NID,
9391                 .dig_in_nid = ALC883_DIGIN_NID,
9392                 .slave_dig_outs = alc1200_slave_dig_outs,
9393                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9394                 .channel_mode = alc883_sixstack_modes,
9395                 .input_mux = &alc883_capture_source,
9396         },
9397         [ALC889A_MB31] = {
9398                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9399                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9400                         alc880_gpio1_init_verbs },
9401                 .adc_nids = alc883_adc_nids,
9402                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9403                 .dac_nids = alc883_dac_nids,
9404                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9405                 .channel_mode = alc889A_mb31_6ch_modes,
9406                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9407                 .input_mux = &alc889A_mb31_capture_source,
9408                 .dig_out_nid = ALC883_DIGOUT_NID,
9409                 .unsol_event = alc889A_mb31_unsol_event,
9410                 .init_hook = alc889A_mb31_automute,
9411         },
9412         [ALC883_SONY_VAIO_TT] = {
9413                 .mixers = { alc883_vaiott_mixer },
9414                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9415                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9416                 .dac_nids = alc883_dac_nids,
9417                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9418                 .channel_mode = alc883_3ST_2ch_modes,
9419                 .input_mux = &alc883_capture_source,
9420                 .unsol_event = alc_automute_amp_unsol_event,
9421                 .init_hook = alc883_vaiott_init_hook,
9422         },
9423 };
9424
9425
9426 /*
9427  * Pin config fixes
9428  */
9429 enum {
9430         PINFIX_ABIT_AW9D_MAX
9431 };
9432
9433 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9434         { 0x15, 0x01080104 }, /* side */
9435         { 0x16, 0x01011012 }, /* rear */
9436         { 0x17, 0x01016011 }, /* clfe */
9437         { }
9438 };
9439
9440 static const struct alc_pincfg *alc882_pin_fixes[] = {
9441         [PINFIX_ABIT_AW9D_MAX] = alc882_abit_aw9d_pinfix,
9442 };
9443
9444 static struct snd_pci_quirk alc882_pinfix_tbl[] = {
9445         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9446         {}
9447 };
9448
9449 /*
9450  * BIOS auto configuration
9451  */
9452 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9453                                               hda_nid_t nid, int pin_type,
9454                                               int dac_idx)
9455 {
9456         /* set as output */
9457         struct alc_spec *spec = codec->spec;
9458         int idx;
9459
9460         alc_set_pin_output(codec, nid, pin_type);
9461         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9462                 idx = 4;
9463         else
9464                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9465         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9466
9467 }
9468
9469 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9470 {
9471         struct alc_spec *spec = codec->spec;
9472         int i;
9473
9474         for (i = 0; i <= HDA_SIDE; i++) {
9475                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9476                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9477                 if (nid)
9478                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9479                                                           i);
9480         }
9481 }
9482
9483 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9484 {
9485         struct alc_spec *spec = codec->spec;
9486         hda_nid_t pin;
9487
9488         pin = spec->autocfg.hp_pins[0];
9489         if (pin) /* connect to front */
9490                 /* use dac 0 */
9491                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9492         pin = spec->autocfg.speaker_pins[0];
9493         if (pin)
9494                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9495 }
9496
9497 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9498 {
9499         struct alc_spec *spec = codec->spec;
9500         int i;
9501
9502         for (i = 0; i < AUTO_PIN_LAST; i++) {
9503                 hda_nid_t nid = spec->autocfg.input_pins[i];
9504                 if (!nid)
9505                         continue;
9506                 alc_set_input_pin(codec, nid, i);
9507                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9508                         snd_hda_codec_write(codec, nid, 0,
9509                                             AC_VERB_SET_AMP_GAIN_MUTE,
9510                                             AMP_OUT_MUTE);
9511         }
9512 }
9513
9514 static void alc882_auto_init_input_src(struct hda_codec *codec)
9515 {
9516         struct alc_spec *spec = codec->spec;
9517         int c;
9518
9519         for (c = 0; c < spec->num_adc_nids; c++) {
9520                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9521                 hda_nid_t nid = spec->capsrc_nids[c];
9522                 unsigned int mux_idx;
9523                 const struct hda_input_mux *imux;
9524                 int conns, mute, idx, item;
9525
9526                 conns = snd_hda_get_connections(codec, nid, conn_list,
9527                                                 ARRAY_SIZE(conn_list));
9528                 if (conns < 0)
9529                         continue;
9530                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9531                 imux = &spec->input_mux[mux_idx];
9532                 for (idx = 0; idx < conns; idx++) {
9533                         /* if the current connection is the selected one,
9534                          * unmute it as default - otherwise mute it
9535                          */
9536                         mute = AMP_IN_MUTE(idx);
9537                         for (item = 0; item < imux->num_items; item++) {
9538                                 if (imux->items[item].index == idx) {
9539                                         if (spec->cur_mux[c] == item)
9540                                                 mute = AMP_IN_UNMUTE(idx);
9541                                         break;
9542                                 }
9543                         }
9544                         /* check if we have a selector or mixer
9545                          * we could check for the widget type instead, but
9546                          * just check for Amp-In presence (in case of mixer
9547                          * without amp-in there is something wrong, this
9548                          * function shouldn't be used or capsrc nid is wrong)
9549                          */
9550                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9551                                 snd_hda_codec_write(codec, nid, 0,
9552                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9553                                                     mute);
9554                         else if (mute != AMP_IN_MUTE(idx))
9555                                 snd_hda_codec_write(codec, nid, 0,
9556                                                     AC_VERB_SET_CONNECT_SEL,
9557                                                     idx);
9558                 }
9559         }
9560 }
9561
9562 /* add mic boosts if needed */
9563 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9564 {
9565         struct alc_spec *spec = codec->spec;
9566         int err;
9567         hda_nid_t nid;
9568
9569         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9570         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9571                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9572                                   "Mic Boost",
9573                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9574                 if (err < 0)
9575                         return err;
9576         }
9577         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9578         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9579                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9580                                   "Front Mic Boost",
9581                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9582                 if (err < 0)
9583                         return err;
9584         }
9585         return 0;
9586 }
9587
9588 /* almost identical with ALC880 parser... */
9589 static int alc882_parse_auto_config(struct hda_codec *codec)
9590 {
9591         struct alc_spec *spec = codec->spec;
9592         struct auto_pin_cfg *autocfg = &spec->autocfg;
9593         unsigned int wcap;
9594         int i;
9595         int err = alc880_parse_auto_config(codec);
9596
9597         if (err < 0)
9598                 return err;
9599         else if (!err)
9600                 return 0; /* no config found */
9601
9602         err = alc_auto_add_mic_boost(codec);
9603         if (err < 0)
9604                 return err;
9605
9606         /* hack - override the init verbs */
9607         spec->init_verbs[0] = alc883_auto_init_verbs;
9608         /* if ADC 0x07 is available, initialize it, too */
9609         wcap = get_wcaps(codec, 0x07);
9610         wcap = get_wcaps_type(wcap);
9611         if (wcap == AC_WID_AUD_IN)
9612                 add_verb(spec, alc882_adc1_init_verbs);
9613
9614         /* digital-mic input pin is excluded in alc880_auto_create..()
9615          * because it's under 0x18
9616          */
9617         if (autocfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
9618             autocfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
9619                 struct hda_input_mux *imux = &spec->private_imux[0];
9620                 for (i = 1; i < 3; i++)
9621                         memcpy(&spec->private_imux[i],
9622                                &spec->private_imux[0],
9623                                sizeof(spec->private_imux[0]));
9624                 imux->items[imux->num_items].label = "Int DMic";
9625                 imux->items[imux->num_items].index = 0x0b;
9626                 imux->num_items++;
9627                 spec->num_mux_defs = 3;
9628                 spec->input_mux = spec->private_imux;
9629         }
9630
9631         return 1; /* config found */
9632 }
9633
9634 /* additional initialization for auto-configuration model */
9635 static void alc882_auto_init(struct hda_codec *codec)
9636 {
9637         struct alc_spec *spec = codec->spec;
9638         alc882_auto_init_multi_out(codec);
9639         alc882_auto_init_hp_out(codec);
9640         alc882_auto_init_analog_input(codec);
9641         alc882_auto_init_input_src(codec);
9642         if (spec->unsol_event)
9643                 alc_inithook(codec);
9644 }
9645
9646 static int patch_alc882(struct hda_codec *codec)
9647 {
9648         struct alc_spec *spec;
9649         int err, board_config;
9650
9651         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9652         if (spec == NULL)
9653                 return -ENOMEM;
9654
9655         codec->spec = spec;
9656
9657         switch (codec->vendor_id) {
9658         case 0x10ec0882:
9659         case 0x10ec0885:
9660                 break;
9661         default:
9662                 /* ALC883 and variants */
9663                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9664                 break;
9665         }
9666
9667         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
9668                                                   alc882_models,
9669                                                   alc882_cfg_tbl);
9670
9671         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
9672                 board_config = snd_hda_check_board_codec_sid_config(codec,
9673                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
9674
9675         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
9676                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
9677                        codec->chip_name);
9678                 board_config = ALC882_AUTO;
9679         }
9680
9681         alc_fix_pincfg(codec, alc882_pinfix_tbl, alc882_pin_fixes);
9682
9683         if (board_config == ALC882_AUTO) {
9684                 /* automatic parse from the BIOS config */
9685                 err = alc882_parse_auto_config(codec);
9686                 if (err < 0) {
9687                         alc_free(codec);
9688                         return err;
9689                 } else if (!err) {
9690                         printk(KERN_INFO
9691                                "hda_codec: Cannot set up configuration "
9692                                "from BIOS.  Using base mode...\n");
9693                         board_config = ALC882_3ST_DIG;
9694                 }
9695         }
9696
9697         err = snd_hda_attach_beep_device(codec, 0x1);
9698         if (err < 0) {
9699                 alc_free(codec);
9700                 return err;
9701         }
9702
9703         if (board_config != ALC882_AUTO)
9704                 setup_preset(spec, &alc882_presets[board_config]);
9705
9706         spec->stream_analog_playback = &alc882_pcm_analog_playback;
9707         spec->stream_analog_capture = &alc882_pcm_analog_capture;
9708         /* FIXME: setup DAC5 */
9709         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
9710         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
9711
9712         spec->stream_digital_playback = &alc882_pcm_digital_playback;
9713         spec->stream_digital_capture = &alc882_pcm_digital_capture;
9714
9715         if (codec->vendor_id == 0x10ec0888)
9716                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9717
9718         if (!spec->adc_nids && spec->input_mux) {
9719                 int i;
9720                 spec->num_adc_nids = 0;
9721                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
9722                         hda_nid_t cap;
9723                         hda_nid_t nid = alc882_adc_nids[i];
9724                         unsigned int wcap = get_wcaps(codec, nid);
9725                         /* get type */
9726                         wcap = get_wcaps_type(wcap);
9727                         if (wcap != AC_WID_AUD_IN)
9728                                 continue;
9729                         spec->private_adc_nids[spec->num_adc_nids] = nid;
9730                         err = snd_hda_get_connections(codec, nid, &cap, 1);
9731                         if (err < 0)
9732                                 continue;
9733                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
9734                         spec->num_adc_nids++;
9735                 }
9736                 spec->adc_nids = spec->private_adc_nids;
9737                 spec->capsrc_nids = spec->private_capsrc_nids;
9738         }
9739
9740         set_capture_mixer(spec);
9741         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9742
9743         spec->vmaster_nid = 0x0c;
9744
9745         codec->patch_ops = alc_patch_ops;
9746         if (board_config == ALC882_AUTO)
9747                 spec->init_hook = alc882_auto_init;
9748 #ifdef CONFIG_SND_HDA_POWER_SAVE
9749         if (!spec->loopback.amplist)
9750                 spec->loopback.amplist = alc882_loopbacks;
9751 #endif
9752         codec->proc_widget_hook = print_realtek_coef;
9753
9754         return 0;
9755 }
9756
9757
9758 /*
9759  * ALC262 support
9760  */
9761
9762 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9763 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9764
9765 #define alc262_dac_nids         alc260_dac_nids
9766 #define alc262_adc_nids         alc882_adc_nids
9767 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9768 #define alc262_capsrc_nids      alc882_capsrc_nids
9769 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9770
9771 #define alc262_modes            alc260_modes
9772 #define alc262_capture_source   alc882_capture_source
9773
9774 static hda_nid_t alc262_dmic_adc_nids[1] = {
9775         /* ADC0 */
9776         0x09
9777 };
9778
9779 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9780
9781 static struct snd_kcontrol_new alc262_base_mixer[] = {
9782         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9783         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9784         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9785         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9786         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9787         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9788         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9789         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9790         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9791         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9792         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9793         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9794         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
9795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9796         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
9797         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
9798         { } /* end */
9799 };
9800
9801 /* update HP, line and mono-out pins according to the master switch */
9802 static void alc262_hp_master_update(struct hda_codec *codec)
9803 {
9804         struct alc_spec *spec = codec->spec;
9805         int val = spec->master_sw;
9806
9807         /* HP & line-out */
9808         snd_hda_codec_write_cache(codec, 0x1b, 0,
9809                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9810                                   val ? PIN_HP : 0);
9811         snd_hda_codec_write_cache(codec, 0x15, 0,
9812                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9813                                   val ? PIN_HP : 0);
9814         /* mono (speaker) depending on the HP jack sense */
9815         val = val && !spec->jack_present;
9816         snd_hda_codec_write_cache(codec, 0x16, 0,
9817                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
9818                                   val ? PIN_OUT : 0);
9819 }
9820
9821 static void alc262_hp_bpc_automute(struct hda_codec *codec)
9822 {
9823         struct alc_spec *spec = codec->spec;
9824         unsigned int presence;
9825         presence = snd_hda_codec_read(codec, 0x1b, 0,
9826                                       AC_VERB_GET_PIN_SENSE, 0);
9827         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9828         alc262_hp_master_update(codec);
9829 }
9830
9831 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
9832 {
9833         if ((res >> 26) != ALC880_HP_EVENT)
9834                 return;
9835         alc262_hp_bpc_automute(codec);
9836 }
9837
9838 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
9839 {
9840         struct alc_spec *spec = codec->spec;
9841         unsigned int presence;
9842         presence = snd_hda_codec_read(codec, 0x15, 0,
9843                                       AC_VERB_GET_PIN_SENSE, 0);
9844         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
9845         alc262_hp_master_update(codec);
9846 }
9847
9848 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
9849                                            unsigned int res)
9850 {
9851         if ((res >> 26) != ALC880_HP_EVENT)
9852                 return;
9853         alc262_hp_wildwest_automute(codec);
9854 }
9855
9856 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
9857
9858 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
9859                                    struct snd_ctl_elem_value *ucontrol)
9860 {
9861         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
9862         struct alc_spec *spec = codec->spec;
9863         int val = !!*ucontrol->value.integer.value;
9864
9865         if (val == spec->master_sw)
9866                 return 0;
9867         spec->master_sw = val;
9868         alc262_hp_master_update(codec);
9869         return 1;
9870 }
9871
9872 #define ALC262_HP_MASTER_SWITCH                                 \
9873         {                                                       \
9874                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
9875                 .name = "Master Playback Switch",               \
9876                 .info = snd_ctl_boolean_mono_info,              \
9877                 .get = alc262_hp_master_sw_get,                 \
9878                 .put = alc262_hp_master_sw_put,                 \
9879         }
9880
9881 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
9882         ALC262_HP_MASTER_SWITCH,
9883         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9884         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9885         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9886         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9887                               HDA_OUTPUT),
9888         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9889                             HDA_OUTPUT),
9890         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9891         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9892         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9893         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
9894         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
9895         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
9896         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9897         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9898         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9899         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9900         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
9901         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
9902         { } /* end */
9903 };
9904
9905 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
9906         ALC262_HP_MASTER_SWITCH,
9907         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9908         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9909         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9910         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9911         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
9912                               HDA_OUTPUT),
9913         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
9914                             HDA_OUTPUT),
9915         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
9916         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
9917         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
9918         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9919         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9920         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9921         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9922         { } /* end */
9923 };
9924
9925 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
9926         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9927         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9928         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
9929         { } /* end */
9930 };
9931
9932 /* mute/unmute internal speaker according to the hp jack and mute state */
9933 static void alc262_hp_t5735_init_hook(struct hda_codec *codec)
9934 {
9935         struct alc_spec *spec = codec->spec;
9936
9937         spec->autocfg.hp_pins[0] = 0x15;
9938         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
9939         alc_automute_amp(codec);
9940 }
9941
9942 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
9943         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9944         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9945         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
9946         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
9947         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9948         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9949         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9950         { } /* end */
9951 };
9952
9953 static struct hda_verb alc262_hp_t5735_verbs[] = {
9954         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9955         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9956
9957         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9958         { }
9959 };
9960
9961 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
9962         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9963         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
9964         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
9965         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
9966         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
9967         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
9968         { } /* end */
9969 };
9970
9971 static struct hda_verb alc262_hp_rp5700_verbs[] = {
9972         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9973         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9974         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9976         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
9977         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9978         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9979         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
9980         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9981         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
9982         {}
9983 };
9984
9985 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
9986         .num_items = 1,
9987         .items = {
9988                 { "Line", 0x1 },
9989         },
9990 };
9991
9992 /* bind hp and internal speaker mute (with plug check) as master switch */
9993 static void alc262_hippo_master_update(struct hda_codec *codec)
9994 {
9995         struct alc_spec *spec = codec->spec;
9996         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
9997         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
9998         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
9999         unsigned int mute;
10000
10001         /* HP */
10002         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10003         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10004                                  HDA_AMP_MUTE, mute);
10005         /* mute internal speaker per jack sense */
10006         if (spec->jack_present)
10007                 mute = HDA_AMP_MUTE;
10008         if (line_nid)
10009                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10010                                          HDA_AMP_MUTE, mute);
10011         if (speaker_nid && speaker_nid != line_nid)
10012                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10013                                          HDA_AMP_MUTE, mute);
10014 }
10015
10016 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10017
10018 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10019                                       struct snd_ctl_elem_value *ucontrol)
10020 {
10021         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10022         struct alc_spec *spec = codec->spec;
10023         int val = !!*ucontrol->value.integer.value;
10024
10025         if (val == spec->master_sw)
10026                 return 0;
10027         spec->master_sw = val;
10028         alc262_hippo_master_update(codec);
10029         return 1;
10030 }
10031
10032 #define ALC262_HIPPO_MASTER_SWITCH                              \
10033         {                                                       \
10034                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10035                 .name = "Master Playback Switch",               \
10036                 .info = snd_ctl_boolean_mono_info,              \
10037                 .get = alc262_hippo_master_sw_get,              \
10038                 .put = alc262_hippo_master_sw_put,              \
10039         }
10040
10041 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10042         ALC262_HIPPO_MASTER_SWITCH,
10043         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10044         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10045         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10046         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10047         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10048         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10049         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10050         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10051         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10052         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10053         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10054         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10055         { } /* end */
10056 };
10057
10058 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10059         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10060         ALC262_HIPPO_MASTER_SWITCH,
10061         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10062         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10063         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10064         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10065         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10066         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10067         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10068         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10069         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10070         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10071         { } /* end */
10072 };
10073
10074 /* mute/unmute internal speaker according to the hp jack and mute state */
10075 static void alc262_hippo_automute(struct hda_codec *codec)
10076 {
10077         struct alc_spec *spec = codec->spec;
10078         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10079         unsigned int present;
10080
10081         /* need to execute and sync at first */
10082         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
10083         present = snd_hda_codec_read(codec, hp_nid, 0,
10084                                      AC_VERB_GET_PIN_SENSE, 0);
10085         spec->jack_present = (present & 0x80000000) != 0;
10086         alc262_hippo_master_update(codec);
10087 }
10088
10089 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10090 {
10091         if ((res >> 26) != ALC880_HP_EVENT)
10092                 return;
10093         alc262_hippo_automute(codec);
10094 }
10095
10096 static void alc262_hippo_init_hook(struct hda_codec *codec)
10097 {
10098         struct alc_spec *spec = codec->spec;
10099
10100         spec->autocfg.hp_pins[0] = 0x15;
10101         spec->autocfg.speaker_pins[0] = 0x14;
10102         alc262_hippo_automute(codec);
10103 }
10104
10105 static void alc262_hippo1_init_hook(struct hda_codec *codec)
10106 {
10107         struct alc_spec *spec = codec->spec;
10108
10109         spec->autocfg.hp_pins[0] = 0x1b;
10110         spec->autocfg.speaker_pins[0] = 0x14;
10111         alc262_hippo_automute(codec);
10112 }
10113
10114
10115 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10116         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10117         ALC262_HIPPO_MASTER_SWITCH,
10118         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10119         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10120         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10121         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10122         { } /* end */
10123 };
10124
10125 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10126         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10127         ALC262_HIPPO_MASTER_SWITCH,
10128         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10129         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10130         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10131         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10132         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10133         { } /* end */
10134 };
10135
10136 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10137         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10138         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10139         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10140         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10141         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10142         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10143         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10144         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10145         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10146         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10147         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10148         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10149         { } /* end */
10150 };
10151
10152 static struct hda_verb alc262_tyan_verbs[] = {
10153         /* Headphone automute */
10154         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10155         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10156         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10157
10158         /* P11 AUX_IN, white 4-pin connector */
10159         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10160         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10161         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10162         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10163
10164         {}
10165 };
10166
10167 /* unsolicited event for HP jack sensing */
10168 static void alc262_tyan_init_hook(struct hda_codec *codec)
10169 {
10170         struct alc_spec *spec = codec->spec;
10171
10172         spec->autocfg.hp_pins[0] = 0x1b;
10173         spec->autocfg.speaker_pins[0] = 0x15;
10174         alc_automute_amp(codec);
10175 }
10176
10177
10178 #define alc262_capture_mixer            alc882_capture_mixer
10179 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10180
10181 /*
10182  * generic initialization of ADC, input mixers and output mixers
10183  */
10184 static struct hda_verb alc262_init_verbs[] = {
10185         /*
10186          * Unmute ADC0-2 and set the default input to mic-in
10187          */
10188         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10189         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10190         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10191         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10192         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10193         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10194
10195         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10196          * mixer widget
10197          * Note: PASD motherboards uses the Line In 2 as the input for
10198          * front panel mic (mic 2)
10199          */
10200         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10201         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10202         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10203         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10204         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10205         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10206
10207         /*
10208          * Set up output mixers (0x0c - 0x0e)
10209          */
10210         /* set vol=0 to output mixers */
10211         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10212         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10213         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10214         /* set up input amps for analog loopback */
10215         /* Amp Indices: DAC = 0, mixer = 1 */
10216         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10217         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10218         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10219         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10220         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10221         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10222
10223         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10224         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10225         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10226         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10227         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10228         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10229
10230         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10231         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10232         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10233         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10234         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10235
10236         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10237         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10238
10239         /* FIXME: use matrix-type input source selection */
10240         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10241         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10242         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10243         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10244         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10245         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10246         /* Input mixer2 */
10247         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10248         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10249         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10250         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10251         /* Input mixer3 */
10252         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10253         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10254         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10255         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10256
10257         { }
10258 };
10259
10260 static struct hda_verb alc262_eapd_verbs[] = {
10261         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10262         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10263         { }
10264 };
10265
10266 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10267         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10268         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10269         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10270
10271         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10272         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10273         {}
10274 };
10275
10276 static struct hda_verb alc262_sony_unsol_verbs[] = {
10277         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10278         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10279         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10280
10281         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10282         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10283         {}
10284 };
10285
10286 static struct hda_input_mux alc262_dmic_capture_source = {
10287         .num_items = 2,
10288         .items = {
10289                 { "Int DMic", 0x9 },
10290                 { "Mic", 0x0 },
10291         },
10292 };
10293
10294 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10295         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10296         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10297         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10298         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10299         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10300         { } /* end */
10301 };
10302
10303 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10304         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10305         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10306         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10307         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10308         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10309         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10310         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10311         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10312         {}
10313 };
10314
10315 static void alc262_dmic_automute(struct hda_codec *codec)
10316 {
10317         unsigned int present;
10318
10319         present = snd_hda_codec_read(codec, 0x18, 0,
10320                                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
10321         snd_hda_codec_write(codec, 0x22, 0,
10322                                 AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x09);
10323 }
10324
10325
10326 /* unsolicited event for HP jack sensing */
10327 static void alc262_toshiba_s06_unsol_event(struct hda_codec *codec,
10328                                        unsigned int res)
10329 {
10330         if ((res >> 26) == ALC880_MIC_EVENT)
10331                 alc262_dmic_automute(codec);
10332         else
10333                 alc_sku_unsol_event(codec, res);
10334 }
10335
10336 static void alc262_toshiba_s06_init_hook(struct hda_codec *codec)
10337 {
10338         struct alc_spec *spec = codec->spec;
10339
10340         spec->autocfg.hp_pins[0] = 0x15;
10341         spec->autocfg.speaker_pins[0] = 0x14;
10342         alc_automute_pin(codec);
10343         alc262_dmic_automute(codec);
10344 }
10345
10346 /*
10347  * nec model
10348  *  0x15 = headphone
10349  *  0x16 = internal speaker
10350  *  0x18 = external mic
10351  */
10352
10353 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10354         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10355         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10356
10357         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10358         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10359         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10360
10361         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10362         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10363         { } /* end */
10364 };
10365
10366 static struct hda_verb alc262_nec_verbs[] = {
10367         /* Unmute Speaker */
10368         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10369
10370         /* Headphone */
10371         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10372         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10373
10374         /* External mic to headphone */
10375         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10376         /* External mic to speaker */
10377         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10378         {}
10379 };
10380
10381 /*
10382  * fujitsu model
10383  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10384  *  0x1b = port replicator headphone out
10385  */
10386
10387 #define ALC_HP_EVENT    0x37
10388
10389 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10390         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10391         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10392         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10393         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10394         {}
10395 };
10396
10397 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10398         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10399         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10400         {}
10401 };
10402
10403 static struct hda_input_mux alc262_fujitsu_capture_source = {
10404         .num_items = 3,
10405         .items = {
10406                 { "Mic", 0x0 },
10407                 { "Int Mic", 0x1 },
10408                 { "CD", 0x4 },
10409         },
10410 };
10411
10412 static struct hda_input_mux alc262_HP_capture_source = {
10413         .num_items = 5,
10414         .items = {
10415                 { "Mic", 0x0 },
10416                 { "Front Mic", 0x1 },
10417                 { "Line", 0x2 },
10418                 { "CD", 0x4 },
10419                 { "AUX IN", 0x6 },
10420         },
10421 };
10422
10423 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10424         .num_items = 4,
10425         .items = {
10426                 { "Mic", 0x0 },
10427                 { "Front Mic", 0x2 },
10428                 { "Line", 0x1 },
10429                 { "CD", 0x4 },
10430         },
10431 };
10432
10433 /* mute/unmute internal speaker according to the hp jacks and mute state */
10434 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10435 {
10436         struct alc_spec *spec = codec->spec;
10437         unsigned int mute;
10438
10439         if (force || !spec->sense_updated) {
10440                 unsigned int present;
10441                 /* need to execute and sync at first */
10442                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10443                 /* check laptop HP jack */
10444                 present = snd_hda_codec_read(codec, 0x14, 0,
10445                                              AC_VERB_GET_PIN_SENSE, 0);
10446                 /* need to execute and sync at first */
10447                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10448                 /* check docking HP jack */
10449                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10450                                               AC_VERB_GET_PIN_SENSE, 0);
10451                 if (present & AC_PINSENSE_PRESENCE)
10452                         spec->jack_present = 1;
10453                 else
10454                         spec->jack_present = 0;
10455                 spec->sense_updated = 1;
10456         }
10457         /* unmute internal speaker only if both HPs are unplugged and
10458          * master switch is on
10459          */
10460         if (spec->jack_present)
10461                 mute = HDA_AMP_MUTE;
10462         else
10463                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10464         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10465                                  HDA_AMP_MUTE, mute);
10466 }
10467
10468 /* unsolicited event for HP jack sensing */
10469 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10470                                        unsigned int res)
10471 {
10472         if ((res >> 26) != ALC_HP_EVENT)
10473                 return;
10474         alc262_fujitsu_automute(codec, 1);
10475 }
10476
10477 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10478 {
10479         alc262_fujitsu_automute(codec, 1);
10480 }
10481
10482 /* bind volumes of both NID 0x0c and 0x0d */
10483 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10484         .ops = &snd_hda_bind_vol,
10485         .values = {
10486                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10487                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10488                 0
10489         },
10490 };
10491
10492 /* mute/unmute internal speaker according to the hp jack and mute state */
10493 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10494 {
10495         struct alc_spec *spec = codec->spec;
10496         unsigned int mute;
10497
10498         if (force || !spec->sense_updated) {
10499                 unsigned int present_int_hp;
10500                 /* need to execute and sync at first */
10501                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10502                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10503                                         AC_VERB_GET_PIN_SENSE, 0);
10504                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10505                 spec->sense_updated = 1;
10506         }
10507         if (spec->jack_present) {
10508                 /* mute internal speaker */
10509                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10510                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10511                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10512                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10513         } else {
10514                 /* unmute internal speaker if necessary */
10515                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10516                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10517                                          HDA_AMP_MUTE, mute);
10518                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10519                                          HDA_AMP_MUTE, mute);
10520         }
10521 }
10522
10523 /* unsolicited event for HP jack sensing */
10524 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10525                                        unsigned int res)
10526 {
10527         if ((res >> 26) != ALC_HP_EVENT)
10528                 return;
10529         alc262_lenovo_3000_automute(codec, 1);
10530 }
10531
10532 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10533                                   int dir, int idx, long *valp)
10534 {
10535         int i, change = 0;
10536
10537         for (i = 0; i < 2; i++, valp++)
10538                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10539                                                    HDA_AMP_MUTE,
10540                                                    *valp ? 0 : HDA_AMP_MUTE);
10541         return change;
10542 }
10543
10544 /* bind hp and internal speaker mute (with plug check) */
10545 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10546                                          struct snd_ctl_elem_value *ucontrol)
10547 {
10548         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10549         long *valp = ucontrol->value.integer.value;
10550         int change;
10551
10552         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10553         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10554         if (change)
10555                 alc262_fujitsu_automute(codec, 0);
10556         return change;
10557 }
10558
10559 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10560         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10561         {
10562                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10563                 .name = "Master Playback Switch",
10564                 .info = snd_hda_mixer_amp_switch_info,
10565                 .get = snd_hda_mixer_amp_switch_get,
10566                 .put = alc262_fujitsu_master_sw_put,
10567                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10568         },
10569         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10570         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10571         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10572         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10573         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10574         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10575         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10576         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10577         { } /* end */
10578 };
10579
10580 /* bind hp and internal speaker mute (with plug check) */
10581 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10582                                          struct snd_ctl_elem_value *ucontrol)
10583 {
10584         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10585         long *valp = ucontrol->value.integer.value;
10586         int change;
10587
10588         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10589         if (change)
10590                 alc262_lenovo_3000_automute(codec, 0);
10591         return change;
10592 }
10593
10594 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10595         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10596         {
10597                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10598                 .name = "Master Playback Switch",
10599                 .info = snd_hda_mixer_amp_switch_info,
10600                 .get = snd_hda_mixer_amp_switch_get,
10601                 .put = alc262_lenovo_3000_master_sw_put,
10602                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10603         },
10604         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10605         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10606         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10607         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10608         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10609         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10610         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10611         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10612         { } /* end */
10613 };
10614
10615 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10616         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10617         ALC262_HIPPO_MASTER_SWITCH,
10618         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10619         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10620         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10621         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10622         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10623         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10624         { } /* end */
10625 };
10626
10627 /* additional init verbs for Benq laptops */
10628 static struct hda_verb alc262_EAPD_verbs[] = {
10629         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10630         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10631         {}
10632 };
10633
10634 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10635         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10636         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10637
10638         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10639         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10640         {}
10641 };
10642
10643 /* Samsung Q1 Ultra Vista model setup */
10644 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10645         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10646         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10647         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10648         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10649         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10650         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10651         { } /* end */
10652 };
10653
10654 static struct hda_verb alc262_ultra_verbs[] = {
10655         /* output mixer */
10656         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10657         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10658         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10659         /* speaker */
10660         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10661         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10662         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10663         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10664         /* HP */
10665         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10666         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10667         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10668         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10669         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10670         /* internal mic */
10671         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10672         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10673         /* ADC, choose mic */
10674         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10675         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10676         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10677         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10678         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10679         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10680         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10681         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10682         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10683         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10684         {}
10685 };
10686
10687 /* mute/unmute internal speaker according to the hp jack and mute state */
10688 static void alc262_ultra_automute(struct hda_codec *codec)
10689 {
10690         struct alc_spec *spec = codec->spec;
10691         unsigned int mute;
10692
10693         mute = 0;
10694         /* auto-mute only when HP is used as HP */
10695         if (!spec->cur_mux[0]) {
10696                 unsigned int present;
10697                 /* need to execute and sync at first */
10698                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10699                 present = snd_hda_codec_read(codec, 0x15, 0,
10700                                              AC_VERB_GET_PIN_SENSE, 0);
10701                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10702                 if (spec->jack_present)
10703                         mute = HDA_AMP_MUTE;
10704         }
10705         /* mute/unmute internal speaker */
10706         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10707                                  HDA_AMP_MUTE, mute);
10708         /* mute/unmute HP */
10709         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10710                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10711 }
10712
10713 /* unsolicited event for HP jack sensing */
10714 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10715                                        unsigned int res)
10716 {
10717         if ((res >> 26) != ALC880_HP_EVENT)
10718                 return;
10719         alc262_ultra_automute(codec);
10720 }
10721
10722 static struct hda_input_mux alc262_ultra_capture_source = {
10723         .num_items = 2,
10724         .items = {
10725                 { "Mic", 0x1 },
10726                 { "Headphone", 0x7 },
10727         },
10728 };
10729
10730 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10731                                      struct snd_ctl_elem_value *ucontrol)
10732 {
10733         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10734         struct alc_spec *spec = codec->spec;
10735         int ret;
10736
10737         ret = alc_mux_enum_put(kcontrol, ucontrol);
10738         if (!ret)
10739                 return 0;
10740         /* reprogram the HP pin as mic or HP according to the input source */
10741         snd_hda_codec_write_cache(codec, 0x15, 0,
10742                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10743                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10744         alc262_ultra_automute(codec); /* mute/unmute HP */
10745         return ret;
10746 }
10747
10748 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10749         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10750         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10751         {
10752                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10753                 .name = "Capture Source",
10754                 .info = alc_mux_enum_info,
10755                 .get = alc_mux_enum_get,
10756                 .put = alc262_ultra_mux_enum_put,
10757         },
10758         { } /* end */
10759 };
10760
10761 /* add playback controls from the parsed DAC table */
10762 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10763                                              const struct auto_pin_cfg *cfg)
10764 {
10765         hda_nid_t nid;
10766         int err;
10767
10768         spec->multiout.num_dacs = 1;    /* only use one dac */
10769         spec->multiout.dac_nids = spec->private_dac_nids;
10770         spec->multiout.dac_nids[0] = 2;
10771
10772         nid = cfg->line_out_pins[0];
10773         if (nid) {
10774                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10775                                   "Front Playback Volume",
10776                                   HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT));
10777                 if (err < 0)
10778                         return err;
10779                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10780                                   "Front Playback Switch",
10781                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
10782                 if (err < 0)
10783                         return err;
10784         }
10785
10786         nid = cfg->speaker_pins[0];
10787         if (nid) {
10788                 if (nid == 0x16) {
10789                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10790                                           "Speaker Playback Volume",
10791                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10792                                                               HDA_OUTPUT));
10793                         if (err < 0)
10794                                 return err;
10795                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10796                                           "Speaker Playback Switch",
10797                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10798                                                               HDA_OUTPUT));
10799                         if (err < 0)
10800                                 return err;
10801                 } else {
10802                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10803                                           "Speaker Playback Switch",
10804                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10805                                                               HDA_OUTPUT));
10806                         if (err < 0)
10807                                 return err;
10808                 }
10809         }
10810         nid = cfg->hp_pins[0];
10811         if (nid) {
10812                 /* spec->multiout.hp_nid = 2; */
10813                 if (nid == 0x16) {
10814                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
10815                                           "Headphone Playback Volume",
10816                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
10817                                                               HDA_OUTPUT));
10818                         if (err < 0)
10819                                 return err;
10820                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10821                                           "Headphone Playback Switch",
10822                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
10823                                                               HDA_OUTPUT));
10824                         if (err < 0)
10825                                 return err;
10826                 } else {
10827                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
10828                                           "Headphone Playback Switch",
10829                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
10830                                                               HDA_OUTPUT));
10831                         if (err < 0)
10832                                 return err;
10833                 }
10834         }
10835         return 0;
10836 }
10837
10838 static int alc262_auto_create_analog_input_ctls(struct alc_spec *spec,
10839                                                 const struct auto_pin_cfg *cfg)
10840 {
10841         int err;
10842
10843         err = alc880_auto_create_analog_input_ctls(spec, cfg);
10844         if (err < 0)
10845                 return err;
10846         /* digital-mic input pin is excluded in alc880_auto_create..()
10847          * because it's under 0x18
10848          */
10849         if (cfg->input_pins[AUTO_PIN_MIC] == 0x12 ||
10850             cfg->input_pins[AUTO_PIN_FRONT_MIC] == 0x12) {
10851                 struct hda_input_mux *imux = &spec->private_imux[0];
10852                 imux->items[imux->num_items].label = "Int Mic";
10853                 imux->items[imux->num_items].index = 0x09;
10854                 imux->num_items++;
10855         }
10856         return 0;
10857 }
10858
10859
10860 /*
10861  * generic initialization of ADC, input mixers and output mixers
10862  */
10863 static struct hda_verb alc262_volume_init_verbs[] = {
10864         /*
10865          * Unmute ADC0-2 and set the default input to mic-in
10866          */
10867         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10868         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10869         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10870         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10871         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10872         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10873
10874         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10875          * mixer widget
10876          * Note: PASD motherboards uses the Line In 2 as the input for
10877          * front panel mic (mic 2)
10878          */
10879         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10880         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10881         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10882         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10883         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10884         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10885
10886         /*
10887          * Set up output mixers (0x0c - 0x0f)
10888          */
10889         /* set vol=0 to output mixers */
10890         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10891         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10892         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10893
10894         /* set up input amps for analog loopback */
10895         /* Amp Indices: DAC = 0, mixer = 1 */
10896         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10897         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10898         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10899         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10900         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10901         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10902
10903         /* FIXME: use matrix-type input source selection */
10904         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10905         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10906         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10907         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10908         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10909         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10910         /* Input mixer2 */
10911         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10912         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10913         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10914         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10915         /* Input mixer3 */
10916         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10917         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10918         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10919         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10920
10921         { }
10922 };
10923
10924 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
10925         /*
10926          * Unmute ADC0-2 and set the default input to mic-in
10927          */
10928         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10929         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10930         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10931         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10932         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10933         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10934
10935         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10936          * mixer widget
10937          * Note: PASD motherboards uses the Line In 2 as the input for
10938          * front panel mic (mic 2)
10939          */
10940         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10941         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10942         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10943         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10944         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10945         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10946         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10947         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10948
10949         /*
10950          * Set up output mixers (0x0c - 0x0e)
10951          */
10952         /* set vol=0 to output mixers */
10953         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10954         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10955         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10956
10957         /* set up input amps for analog loopback */
10958         /* Amp Indices: DAC = 0, mixer = 1 */
10959         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10960         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10961         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10962         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10963         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10964         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10965
10966         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10967         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10968         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
10969
10970         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10971         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
10972
10973         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10974         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10975
10976         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10977         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10978         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10979         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10980         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10981
10982         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10983         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10984         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10985         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10986         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10987         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
10988
10989
10990         /* FIXME: use matrix-type input source selection */
10991         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
10992         /* Input mixer1: only unmute Mic */
10993         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10994         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
10995         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10996         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10997         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10998         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
10999         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11000         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11001         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11002         /* Input mixer2 */
11003         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11004         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11005         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11006         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11007         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11008         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11009         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11010         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11011         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11012         /* Input mixer3 */
11013         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11014         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11015         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11016         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11017         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11018         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11019         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11022
11023         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11024
11025         { }
11026 };
11027
11028 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11029         /*
11030          * Unmute ADC0-2 and set the default input to mic-in
11031          */
11032         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11033         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11034         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11035         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11036         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11037         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11038
11039         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11040          * mixer widget
11041          * Note: PASD motherboards uses the Line In 2 as the input for front
11042          * panel mic (mic 2)
11043          */
11044         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11045         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11046         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11047         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11049         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11050         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11051         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11052         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11053         /*
11054          * Set up output mixers (0x0c - 0x0e)
11055          */
11056         /* set vol=0 to output mixers */
11057         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11058         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11059         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11060
11061         /* set up input amps for analog loopback */
11062         /* Amp Indices: DAC = 0, mixer = 1 */
11063         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11064         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11065         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11066         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11067         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11068         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11069
11070
11071         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11072         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11073         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11074         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11075         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11076         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11077         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11078
11079         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11080         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11081
11082         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11083         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11084
11085         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11086         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11087         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11088         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11089         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11090         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11091
11092         /* FIXME: use matrix-type input source selection */
11093         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11094         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11095         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11096         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11097         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11098         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11099         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11100         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11101         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11102         /* Input mixer2 */
11103         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11104         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11105         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11106         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11107         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11108         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11109         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11110         /* Input mixer3 */
11111         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11112         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11113         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11114         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11115         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11116         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11117         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11118
11119         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11120
11121         { }
11122 };
11123
11124 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11125
11126         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11127         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11128         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11129
11130         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11131         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11132         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11133         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11134
11135         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11136         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11137         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11138         {}
11139 };
11140
11141
11142 #ifdef CONFIG_SND_HDA_POWER_SAVE
11143 #define alc262_loopbacks        alc880_loopbacks
11144 #endif
11145
11146 /* pcm configuration: identical with ALC880 */
11147 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11148 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11149 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11150 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11151
11152 /*
11153  * BIOS auto configuration
11154  */
11155 static int alc262_parse_auto_config(struct hda_codec *codec)
11156 {
11157         struct alc_spec *spec = codec->spec;
11158         int err;
11159         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11160
11161         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11162                                            alc262_ignore);
11163         if (err < 0)
11164                 return err;
11165         if (!spec->autocfg.line_outs) {
11166                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11167                         spec->multiout.max_channels = 2;
11168                         spec->no_analog = 1;
11169                         goto dig_only;
11170                 }
11171                 return 0; /* can't find valid BIOS pin config */
11172         }
11173         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11174         if (err < 0)
11175                 return err;
11176         err = alc262_auto_create_analog_input_ctls(spec, &spec->autocfg);
11177         if (err < 0)
11178                 return err;
11179
11180         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11181
11182  dig_only:
11183         if (spec->autocfg.dig_outs) {
11184                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11185                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11186         }
11187         if (spec->autocfg.dig_in_pin)
11188                 spec->dig_in_nid = ALC262_DIGIN_NID;
11189
11190         if (spec->kctls.list)
11191                 add_mixer(spec, spec->kctls.list);
11192
11193         add_verb(spec, alc262_volume_init_verbs);
11194         spec->num_mux_defs = 1;
11195         spec->input_mux = &spec->private_imux[0];
11196
11197         err = alc_auto_add_mic_boost(codec);
11198         if (err < 0)
11199                 return err;
11200
11201         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11202
11203         return 1;
11204 }
11205
11206 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11207 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11208 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11209 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11210
11211
11212 /* init callback for auto-configuration model -- overriding the default init */
11213 static void alc262_auto_init(struct hda_codec *codec)
11214 {
11215         struct alc_spec *spec = codec->spec;
11216         alc262_auto_init_multi_out(codec);
11217         alc262_auto_init_hp_out(codec);
11218         alc262_auto_init_analog_input(codec);
11219         alc262_auto_init_input_src(codec);
11220         if (spec->unsol_event)
11221                 alc_inithook(codec);
11222 }
11223
11224 /*
11225  * configuration and preset
11226  */
11227 static const char *alc262_models[ALC262_MODEL_LAST] = {
11228         [ALC262_BASIC]          = "basic",
11229         [ALC262_HIPPO]          = "hippo",
11230         [ALC262_HIPPO_1]        = "hippo_1",
11231         [ALC262_FUJITSU]        = "fujitsu",
11232         [ALC262_HP_BPC]         = "hp-bpc",
11233         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11234         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11235         [ALC262_HP_RP5700]      = "hp-rp5700",
11236         [ALC262_BENQ_ED8]       = "benq",
11237         [ALC262_BENQ_T31]       = "benq-t31",
11238         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11239         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11240         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11241         [ALC262_ULTRA]          = "ultra",
11242         [ALC262_LENOVO_3000]    = "lenovo-3000",
11243         [ALC262_NEC]            = "nec",
11244         [ALC262_TYAN]           = "tyan",
11245         [ALC262_AUTO]           = "auto",
11246 };
11247
11248 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11249         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11250         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11251         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11252                            ALC262_HP_BPC),
11253         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11254                            ALC262_HP_BPC),
11255         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11256                            ALC262_HP_BPC),
11257         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11258         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11259         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11260         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11261         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11262         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11263         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11264         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11265         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11266         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11267         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11268         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11269                       ALC262_HP_TC_T5735),
11270         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11271         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11272         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11273         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11274         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11275         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11276         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11277                            ALC262_SONY_ASSAMD),
11278         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11279                       ALC262_TOSHIBA_RX1),
11280         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11281         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11282         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11283         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11284         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11285                            ALC262_ULTRA),
11286         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11287         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11288         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11289         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11290         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11291         {}
11292 };
11293
11294 static struct alc_config_preset alc262_presets[] = {
11295         [ALC262_BASIC] = {
11296                 .mixers = { alc262_base_mixer },
11297                 .init_verbs = { alc262_init_verbs },
11298                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11299                 .dac_nids = alc262_dac_nids,
11300                 .hp_nid = 0x03,
11301                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11302                 .channel_mode = alc262_modes,
11303                 .input_mux = &alc262_capture_source,
11304         },
11305         [ALC262_HIPPO] = {
11306                 .mixers = { alc262_hippo_mixer },
11307                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11308                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11309                 .dac_nids = alc262_dac_nids,
11310                 .hp_nid = 0x03,
11311                 .dig_out_nid = ALC262_DIGOUT_NID,
11312                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11313                 .channel_mode = alc262_modes,
11314                 .input_mux = &alc262_capture_source,
11315                 .unsol_event = alc262_hippo_unsol_event,
11316                 .init_hook = alc262_hippo_init_hook,
11317         },
11318         [ALC262_HIPPO_1] = {
11319                 .mixers = { alc262_hippo1_mixer },
11320                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11321                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11322                 .dac_nids = alc262_dac_nids,
11323                 .hp_nid = 0x02,
11324                 .dig_out_nid = ALC262_DIGOUT_NID,
11325                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11326                 .channel_mode = alc262_modes,
11327                 .input_mux = &alc262_capture_source,
11328                 .unsol_event = alc262_hippo_unsol_event,
11329                 .init_hook = alc262_hippo1_init_hook,
11330         },
11331         [ALC262_FUJITSU] = {
11332                 .mixers = { alc262_fujitsu_mixer },
11333                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11334                                 alc262_fujitsu_unsol_verbs },
11335                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11336                 .dac_nids = alc262_dac_nids,
11337                 .hp_nid = 0x03,
11338                 .dig_out_nid = ALC262_DIGOUT_NID,
11339                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11340                 .channel_mode = alc262_modes,
11341                 .input_mux = &alc262_fujitsu_capture_source,
11342                 .unsol_event = alc262_fujitsu_unsol_event,
11343                 .init_hook = alc262_fujitsu_init_hook,
11344         },
11345         [ALC262_HP_BPC] = {
11346                 .mixers = { alc262_HP_BPC_mixer },
11347                 .init_verbs = { alc262_HP_BPC_init_verbs },
11348                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11349                 .dac_nids = alc262_dac_nids,
11350                 .hp_nid = 0x03,
11351                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11352                 .channel_mode = alc262_modes,
11353                 .input_mux = &alc262_HP_capture_source,
11354                 .unsol_event = alc262_hp_bpc_unsol_event,
11355                 .init_hook = alc262_hp_bpc_automute,
11356         },
11357         [ALC262_HP_BPC_D7000_WF] = {
11358                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11359                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11360                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11361                 .dac_nids = alc262_dac_nids,
11362                 .hp_nid = 0x03,
11363                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11364                 .channel_mode = alc262_modes,
11365                 .input_mux = &alc262_HP_D7000_capture_source,
11366                 .unsol_event = alc262_hp_wildwest_unsol_event,
11367                 .init_hook = alc262_hp_wildwest_automute,
11368         },
11369         [ALC262_HP_BPC_D7000_WL] = {
11370                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11371                             alc262_HP_BPC_WildWest_option_mixer },
11372                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11373                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11374                 .dac_nids = alc262_dac_nids,
11375                 .hp_nid = 0x03,
11376                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11377                 .channel_mode = alc262_modes,
11378                 .input_mux = &alc262_HP_D7000_capture_source,
11379                 .unsol_event = alc262_hp_wildwest_unsol_event,
11380                 .init_hook = alc262_hp_wildwest_automute,
11381         },
11382         [ALC262_HP_TC_T5735] = {
11383                 .mixers = { alc262_hp_t5735_mixer },
11384                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11385                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11386                 .dac_nids = alc262_dac_nids,
11387                 .hp_nid = 0x03,
11388                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11389                 .channel_mode = alc262_modes,
11390                 .input_mux = &alc262_capture_source,
11391                 .unsol_event = alc_automute_amp_unsol_event,
11392                 .init_hook = alc262_hp_t5735_init_hook,
11393         },
11394         [ALC262_HP_RP5700] = {
11395                 .mixers = { alc262_hp_rp5700_mixer },
11396                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11397                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11398                 .dac_nids = alc262_dac_nids,
11399                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11400                 .channel_mode = alc262_modes,
11401                 .input_mux = &alc262_hp_rp5700_capture_source,
11402         },
11403         [ALC262_BENQ_ED8] = {
11404                 .mixers = { alc262_base_mixer },
11405                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11406                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11407                 .dac_nids = alc262_dac_nids,
11408                 .hp_nid = 0x03,
11409                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11410                 .channel_mode = alc262_modes,
11411                 .input_mux = &alc262_capture_source,
11412         },
11413         [ALC262_SONY_ASSAMD] = {
11414                 .mixers = { alc262_sony_mixer },
11415                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11416                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11417                 .dac_nids = alc262_dac_nids,
11418                 .hp_nid = 0x02,
11419                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11420                 .channel_mode = alc262_modes,
11421                 .input_mux = &alc262_capture_source,
11422                 .unsol_event = alc262_hippo_unsol_event,
11423                 .init_hook = alc262_hippo_init_hook,
11424         },
11425         [ALC262_BENQ_T31] = {
11426                 .mixers = { alc262_benq_t31_mixer },
11427                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11428                                 alc_hp15_unsol_verbs },
11429                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11430                 .dac_nids = alc262_dac_nids,
11431                 .hp_nid = 0x03,
11432                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11433                 .channel_mode = alc262_modes,
11434                 .input_mux = &alc262_capture_source,
11435                 .unsol_event = alc262_hippo_unsol_event,
11436                 .init_hook = alc262_hippo_init_hook,
11437         },
11438         [ALC262_ULTRA] = {
11439                 .mixers = { alc262_ultra_mixer },
11440                 .cap_mixer = alc262_ultra_capture_mixer,
11441                 .init_verbs = { alc262_ultra_verbs },
11442                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11443                 .dac_nids = alc262_dac_nids,
11444                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11445                 .channel_mode = alc262_modes,
11446                 .input_mux = &alc262_ultra_capture_source,
11447                 .adc_nids = alc262_adc_nids, /* ADC0 */
11448                 .capsrc_nids = alc262_capsrc_nids,
11449                 .num_adc_nids = 1, /* single ADC */
11450                 .unsol_event = alc262_ultra_unsol_event,
11451                 .init_hook = alc262_ultra_automute,
11452         },
11453         [ALC262_LENOVO_3000] = {
11454                 .mixers = { alc262_lenovo_3000_mixer },
11455                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11456                                 alc262_lenovo_3000_unsol_verbs },
11457                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11458                 .dac_nids = alc262_dac_nids,
11459                 .hp_nid = 0x03,
11460                 .dig_out_nid = ALC262_DIGOUT_NID,
11461                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11462                 .channel_mode = alc262_modes,
11463                 .input_mux = &alc262_fujitsu_capture_source,
11464                 .unsol_event = alc262_lenovo_3000_unsol_event,
11465         },
11466         [ALC262_NEC] = {
11467                 .mixers = { alc262_nec_mixer },
11468                 .init_verbs = { alc262_nec_verbs },
11469                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11470                 .dac_nids = alc262_dac_nids,
11471                 .hp_nid = 0x03,
11472                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11473                 .channel_mode = alc262_modes,
11474                 .input_mux = &alc262_capture_source,
11475         },
11476         [ALC262_TOSHIBA_S06] = {
11477                 .mixers = { alc262_toshiba_s06_mixer },
11478                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11479                                                         alc262_eapd_verbs },
11480                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11481                 .capsrc_nids = alc262_dmic_capsrc_nids,
11482                 .dac_nids = alc262_dac_nids,
11483                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11484                 .num_adc_nids = 1, /* single ADC */
11485                 .dig_out_nid = ALC262_DIGOUT_NID,
11486                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11487                 .channel_mode = alc262_modes,
11488                 .input_mux = &alc262_dmic_capture_source,
11489                 .unsol_event = alc262_toshiba_s06_unsol_event,
11490                 .init_hook = alc262_toshiba_s06_init_hook,
11491         },
11492         [ALC262_TOSHIBA_RX1] = {
11493                 .mixers = { alc262_toshiba_rx1_mixer },
11494                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11495                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11496                 .dac_nids = alc262_dac_nids,
11497                 .hp_nid = 0x03,
11498                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11499                 .channel_mode = alc262_modes,
11500                 .input_mux = &alc262_capture_source,
11501                 .unsol_event = alc262_hippo_unsol_event,
11502                 .init_hook = alc262_hippo_init_hook,
11503         },
11504         [ALC262_TYAN] = {
11505                 .mixers = { alc262_tyan_mixer },
11506                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11507                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11508                 .dac_nids = alc262_dac_nids,
11509                 .hp_nid = 0x02,
11510                 .dig_out_nid = ALC262_DIGOUT_NID,
11511                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11512                 .channel_mode = alc262_modes,
11513                 .input_mux = &alc262_capture_source,
11514                 .unsol_event = alc_automute_amp_unsol_event,
11515                 .init_hook = alc262_tyan_init_hook,
11516         },
11517 };
11518
11519 static int patch_alc262(struct hda_codec *codec)
11520 {
11521         struct alc_spec *spec;
11522         int board_config;
11523         int err;
11524
11525         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11526         if (spec == NULL)
11527                 return -ENOMEM;
11528
11529         codec->spec = spec;
11530 #if 0
11531         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11532          * under-run
11533          */
11534         {
11535         int tmp;
11536         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11537         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11538         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11539         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11540         }
11541 #endif
11542
11543         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11544
11545         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11546                                                   alc262_models,
11547                                                   alc262_cfg_tbl);
11548
11549         if (board_config < 0) {
11550                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11551                        codec->chip_name);
11552                 board_config = ALC262_AUTO;
11553         }
11554
11555         if (board_config == ALC262_AUTO) {
11556                 /* automatic parse from the BIOS config */
11557                 err = alc262_parse_auto_config(codec);
11558                 if (err < 0) {
11559                         alc_free(codec);
11560                         return err;
11561                 } else if (!err) {
11562                         printk(KERN_INFO
11563                                "hda_codec: Cannot set up configuration "
11564                                "from BIOS.  Using base mode...\n");
11565                         board_config = ALC262_BASIC;
11566                 }
11567         }
11568
11569         if (!spec->no_analog) {
11570                 err = snd_hda_attach_beep_device(codec, 0x1);
11571                 if (err < 0) {
11572                         alc_free(codec);
11573                         return err;
11574                 }
11575         }
11576
11577         if (board_config != ALC262_AUTO)
11578                 setup_preset(spec, &alc262_presets[board_config]);
11579
11580         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11581         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11582
11583         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11584         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11585
11586         if (!spec->adc_nids && spec->input_mux) {
11587                 int i;
11588                 /* check whether the digital-mic has to be supported */
11589                 for (i = 0; i < spec->input_mux->num_items; i++) {
11590                         if (spec->input_mux->items[i].index >= 9)
11591                                 break;
11592                 }
11593                 if (i < spec->input_mux->num_items) {
11594                         /* use only ADC0 */
11595                         spec->adc_nids = alc262_dmic_adc_nids;
11596                         spec->num_adc_nids = 1;
11597                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11598                 } else {
11599                         /* all analog inputs */
11600                         /* check whether NID 0x07 is valid */
11601                         unsigned int wcap = get_wcaps(codec, 0x07);
11602
11603                         /* get type */
11604                         wcap = get_wcaps_type(wcap);
11605                         if (wcap != AC_WID_AUD_IN) {
11606                                 spec->adc_nids = alc262_adc_nids_alt;
11607                                 spec->num_adc_nids =
11608                                         ARRAY_SIZE(alc262_adc_nids_alt);
11609                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11610                         } else {
11611                                 spec->adc_nids = alc262_adc_nids;
11612                                 spec->num_adc_nids =
11613                                         ARRAY_SIZE(alc262_adc_nids);
11614                                 spec->capsrc_nids = alc262_capsrc_nids;
11615                         }
11616                 }
11617         }
11618         if (!spec->cap_mixer && !spec->no_analog)
11619                 set_capture_mixer(spec);
11620         if (!spec->no_analog)
11621                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11622
11623         spec->vmaster_nid = 0x0c;
11624
11625         codec->patch_ops = alc_patch_ops;
11626         if (board_config == ALC262_AUTO)
11627                 spec->init_hook = alc262_auto_init;
11628 #ifdef CONFIG_SND_HDA_POWER_SAVE
11629         if (!spec->loopback.amplist)
11630                 spec->loopback.amplist = alc262_loopbacks;
11631 #endif
11632         codec->proc_widget_hook = print_realtek_coef;
11633
11634         return 0;
11635 }
11636
11637 /*
11638  *  ALC268 channel source setting (2 channel)
11639  */
11640 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11641 #define alc268_modes            alc260_modes
11642
11643 static hda_nid_t alc268_dac_nids[2] = {
11644         /* front, hp */
11645         0x02, 0x03
11646 };
11647
11648 static hda_nid_t alc268_adc_nids[2] = {
11649         /* ADC0-1 */
11650         0x08, 0x07
11651 };
11652
11653 static hda_nid_t alc268_adc_nids_alt[1] = {
11654         /* ADC0 */
11655         0x08
11656 };
11657
11658 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11659
11660 static struct snd_kcontrol_new alc268_base_mixer[] = {
11661         /* output mixer control */
11662         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11663         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11664         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11665         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11666         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11667         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11668         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11669         { }
11670 };
11671
11672 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11673         /* output mixer control */
11674         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11675         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11676         ALC262_HIPPO_MASTER_SWITCH,
11677         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11678         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11679         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11680         { }
11681 };
11682
11683 /* bind Beep switches of both NID 0x0f and 0x10 */
11684 static struct hda_bind_ctls alc268_bind_beep_sw = {
11685         .ops = &snd_hda_bind_sw,
11686         .values = {
11687                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11688                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11689                 0
11690         },
11691 };
11692
11693 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11694         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11695         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11696         { }
11697 };
11698
11699 static struct hda_verb alc268_eapd_verbs[] = {
11700         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11701         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11702         { }
11703 };
11704
11705 /* Toshiba specific */
11706 static struct hda_verb alc268_toshiba_verbs[] = {
11707         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11708         { } /* end */
11709 };
11710
11711 static struct hda_input_mux alc268_acer_lc_capture_source = {
11712         .num_items = 2,
11713         .items = {
11714                 { "i-Mic", 0x6 },
11715                 { "E-Mic", 0x0 },
11716         },
11717 };
11718
11719 /* Acer specific */
11720 /* bind volumes of both NID 0x02 and 0x03 */
11721 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11722         .ops = &snd_hda_bind_vol,
11723         .values = {
11724                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11725                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11726                 0
11727         },
11728 };
11729
11730 /* mute/unmute internal speaker according to the hp jack and mute state */
11731 static void alc268_acer_automute(struct hda_codec *codec, int force)
11732 {
11733         struct alc_spec *spec = codec->spec;
11734         unsigned int mute;
11735
11736         if (force || !spec->sense_updated) {
11737                 unsigned int present;
11738                 present = snd_hda_codec_read(codec, 0x14, 0,
11739                                          AC_VERB_GET_PIN_SENSE, 0);
11740                 spec->jack_present = (present & 0x80000000) != 0;
11741                 spec->sense_updated = 1;
11742         }
11743         if (spec->jack_present)
11744                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11745         else /* unmute internal speaker if necessary */
11746                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11747         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11748                                  HDA_AMP_MUTE, mute);
11749 }
11750
11751
11752 /* bind hp and internal speaker mute (with plug check) */
11753 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11754                                      struct snd_ctl_elem_value *ucontrol)
11755 {
11756         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11757         long *valp = ucontrol->value.integer.value;
11758         int change;
11759
11760         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11761         if (change)
11762                 alc268_acer_automute(codec, 0);
11763         return change;
11764 }
11765
11766 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11767         /* output mixer control */
11768         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11769         {
11770                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11771                 .name = "Master Playback Switch",
11772                 .info = snd_hda_mixer_amp_switch_info,
11773                 .get = snd_hda_mixer_amp_switch_get,
11774                 .put = alc268_acer_master_sw_put,
11775                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11776         },
11777         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11778         { }
11779 };
11780
11781 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11782         /* output mixer control */
11783         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11784         {
11785                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11786                 .name = "Master Playback Switch",
11787                 .info = snd_hda_mixer_amp_switch_info,
11788                 .get = snd_hda_mixer_amp_switch_get,
11789                 .put = alc268_acer_master_sw_put,
11790                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11791         },
11792         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11793         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11794         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11795         { }
11796 };
11797
11798 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11799         /* output mixer control */
11800         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11801         {
11802                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11803                 .name = "Master Playback Switch",
11804                 .info = snd_hda_mixer_amp_switch_info,
11805                 .get = snd_hda_mixer_amp_switch_get,
11806                 .put = alc268_acer_master_sw_put,
11807                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11808         },
11809         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11810         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11811         { }
11812 };
11813
11814 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11815         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11816         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11817         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11818         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11819         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
11820         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
11821         { }
11822 };
11823
11824 static struct hda_verb alc268_acer_verbs[] = {
11825         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
11826         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11827         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11828         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11829         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11830         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11831         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11832         { }
11833 };
11834
11835 /* unsolicited event for HP jack sensing */
11836 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
11837 #define alc268_toshiba_init_hook        alc262_hippo_init_hook
11838
11839 static void alc268_acer_unsol_event(struct hda_codec *codec,
11840                                        unsigned int res)
11841 {
11842         if ((res >> 26) != ALC880_HP_EVENT)
11843                 return;
11844         alc268_acer_automute(codec, 1);
11845 }
11846
11847 static void alc268_acer_init_hook(struct hda_codec *codec)
11848 {
11849         alc268_acer_automute(codec, 1);
11850 }
11851
11852 /* toggle speaker-output according to the hp-jack state */
11853 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
11854 {
11855         unsigned int present;
11856         unsigned char bits;
11857
11858         present = snd_hda_codec_read(codec, 0x15, 0,
11859                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11860         bits = present ? AMP_IN_MUTE(0) : 0;
11861         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
11862                                 AMP_IN_MUTE(0), bits);
11863         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
11864                                 AMP_IN_MUTE(0), bits);
11865 }
11866
11867
11868 static void alc268_acer_mic_automute(struct hda_codec *codec)
11869 {
11870         unsigned int present;
11871
11872         present = snd_hda_codec_read(codec, 0x18, 0,
11873                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11874         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_CONNECT_SEL,
11875                             present ? 0x0 : 0x6);
11876 }
11877
11878 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
11879                                     unsigned int res)
11880 {
11881         if ((res >> 26) == ALC880_HP_EVENT)
11882                 alc268_aspire_one_speaker_automute(codec);
11883         if ((res >> 26) == ALC880_MIC_EVENT)
11884                 alc268_acer_mic_automute(codec);
11885 }
11886
11887 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
11888 {
11889         alc268_aspire_one_speaker_automute(codec);
11890         alc268_acer_mic_automute(codec);
11891 }
11892
11893 static struct snd_kcontrol_new alc268_dell_mixer[] = {
11894         /* output mixer control */
11895         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
11896         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11897         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
11898         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11899         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11900         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11901         { }
11902 };
11903
11904 static struct hda_verb alc268_dell_verbs[] = {
11905         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11906         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11907         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11908         { }
11909 };
11910
11911 /* mute/unmute internal speaker according to the hp jack and mute state */
11912 static void alc268_dell_init_hook(struct hda_codec *codec)
11913 {
11914         struct alc_spec *spec = codec->spec;
11915
11916         spec->autocfg.hp_pins[0] = 0x15;
11917         spec->autocfg.speaker_pins[0] = 0x14;
11918         alc_automute_pin(codec);
11919 }
11920
11921 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
11922         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11923         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11924         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11925         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11926         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
11927         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
11928         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
11929         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11930         { }
11931 };
11932
11933 static struct hda_verb alc267_quanta_il1_verbs[] = {
11934         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11935         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
11936         { }
11937 };
11938
11939 static void alc267_quanta_il1_mic_automute(struct hda_codec *codec)
11940 {
11941         unsigned int present;
11942
11943         present = snd_hda_codec_read(codec, 0x18, 0,
11944                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
11945         snd_hda_codec_write(codec, 0x23, 0,
11946                             AC_VERB_SET_CONNECT_SEL,
11947                             present ? 0x00 : 0x01);
11948 }
11949
11950 static void alc267_quanta_il1_init_hook(struct hda_codec *codec)
11951 {
11952         struct alc_spec *spec = codec->spec;
11953
11954         spec->autocfg.hp_pins[0] = 0x15;
11955         spec->autocfg.speaker_pins[0] = 0x14;
11956         alc_automute_pin(codec);
11957         alc267_quanta_il1_mic_automute(codec);
11958 }
11959
11960 static void alc267_quanta_il1_unsol_event(struct hda_codec *codec,
11961                                            unsigned int res)
11962 {
11963         switch (res >> 26) {
11964         case ALC880_MIC_EVENT:
11965                 alc267_quanta_il1_mic_automute(codec);
11966                 break;
11967         default:
11968                 alc_sku_unsol_event(codec, res);
11969                 break;
11970         }
11971 }
11972
11973 /*
11974  * generic initialization of ADC, input mixers and output mixers
11975  */
11976 static struct hda_verb alc268_base_init_verbs[] = {
11977         /* Unmute DAC0-1 and set vol = 0 */
11978         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11979         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11980
11981         /*
11982          * Set up output mixers (0x0c - 0x0e)
11983          */
11984         /* set vol=0 to output mixers */
11985         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11986         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
11987
11988         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11989         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11990
11991         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11992         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11993         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11994         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11995         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11996         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11997         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11998         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11999
12000         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12001         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12002         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12003         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12004         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12005
12006         /* set PCBEEP vol = 0, mute connections */
12007         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12008         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12009         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12010
12011         /* Unmute Selector 23h,24h and set the default input to mic-in */
12012
12013         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12014         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12015         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12016         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12017
12018         { }
12019 };
12020
12021 /*
12022  * generic initialization of ADC, input mixers and output mixers
12023  */
12024 static struct hda_verb alc268_volume_init_verbs[] = {
12025         /* set output DAC */
12026         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12027         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12028
12029         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12030         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12031         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12032         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12033         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12034
12035         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12036         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12037         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12038
12039         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12040         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12041
12042         /* set PCBEEP vol = 0, mute connections */
12043         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12044         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12045         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12046
12047         { }
12048 };
12049
12050 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12051         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12052         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12053         {
12054                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12055                 /* The multiple "Capture Source" controls confuse alsamixer
12056                  * So call somewhat different..
12057                  */
12058                 /* .name = "Capture Source", */
12059                 .name = "Input Source",
12060                 .count = 1,
12061                 .info = alc_mux_enum_info,
12062                 .get = alc_mux_enum_get,
12063                 .put = alc_mux_enum_put,
12064         },
12065         { } /* end */
12066 };
12067
12068 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12069         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12070         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12071         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12072         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12073         {
12074                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12075                 /* The multiple "Capture Source" controls confuse alsamixer
12076                  * So call somewhat different..
12077                  */
12078                 /* .name = "Capture Source", */
12079                 .name = "Input Source",
12080                 .count = 2,
12081                 .info = alc_mux_enum_info,
12082                 .get = alc_mux_enum_get,
12083                 .put = alc_mux_enum_put,
12084         },
12085         { } /* end */
12086 };
12087
12088 static struct hda_input_mux alc268_capture_source = {
12089         .num_items = 4,
12090         .items = {
12091                 { "Mic", 0x0 },
12092                 { "Front Mic", 0x1 },
12093                 { "Line", 0x2 },
12094                 { "CD", 0x3 },
12095         },
12096 };
12097
12098 static struct hda_input_mux alc268_acer_capture_source = {
12099         .num_items = 3,
12100         .items = {
12101                 { "Mic", 0x0 },
12102                 { "Internal Mic", 0x1 },
12103                 { "Line", 0x2 },
12104         },
12105 };
12106
12107 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12108         .num_items = 3,
12109         .items = {
12110                 { "Mic", 0x0 },
12111                 { "Internal Mic", 0x6 },
12112                 { "Line", 0x2 },
12113         },
12114 };
12115
12116 #ifdef CONFIG_SND_DEBUG
12117 static struct snd_kcontrol_new alc268_test_mixer[] = {
12118         /* Volume widgets */
12119         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12120         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12121         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12122         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12123         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12124         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12125         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12126         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12127         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12128         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12129         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12130         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12131         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12132         /* The below appears problematic on some hardwares */
12133         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12134         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12135         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12136         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12137         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12138
12139         /* Modes for retasking pin widgets */
12140         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12141         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12142         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12143         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12144
12145         /* Controls for GPIO pins, assuming they are configured as outputs */
12146         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12147         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12148         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12149         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12150
12151         /* Switches to allow the digital SPDIF output pin to be enabled.
12152          * The ALC268 does not have an SPDIF input.
12153          */
12154         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12155
12156         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12157          * this output to turn on an external amplifier.
12158          */
12159         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12160         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12161
12162         { } /* end */
12163 };
12164 #endif
12165
12166 /* create input playback/capture controls for the given pin */
12167 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12168                                     const char *ctlname, int idx)
12169 {
12170         char name[32];
12171         hda_nid_t dac;
12172         int err;
12173
12174         sprintf(name, "%s Playback Volume", ctlname);
12175         switch (nid) {
12176         case 0x14:
12177         case 0x16:
12178                 dac = 0x02;
12179                 break;
12180         case 0x15:
12181                 dac = 0x03;
12182                 break;
12183         default:
12184                 return 0;
12185         }
12186         if (spec->multiout.dac_nids[0] != dac &&
12187             spec->multiout.dac_nids[1] != dac) {
12188                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12189                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12190                                                       HDA_OUTPUT));
12191                 if (err < 0)
12192                         return err;
12193                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12194         }
12195
12196         sprintf(name, "%s Playback Switch", ctlname);
12197         if (nid != 0x16)
12198                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12199                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12200         else /* mono */
12201                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12202                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12203         if (err < 0)
12204                 return err;
12205         return 0;
12206 }
12207
12208 /* add playback controls from the parsed DAC table */
12209 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12210                                              const struct auto_pin_cfg *cfg)
12211 {
12212         hda_nid_t nid;
12213         int err;
12214
12215         spec->multiout.dac_nids = spec->private_dac_nids;
12216
12217         nid = cfg->line_out_pins[0];
12218         if (nid) {
12219                 const char *name;
12220                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12221                         name = "Speaker";
12222                 else
12223                         name = "Front";
12224                 err = alc268_new_analog_output(spec, nid, name, 0);
12225                 if (err < 0)
12226                         return err;
12227         }
12228
12229         nid = cfg->speaker_pins[0];
12230         if (nid == 0x1d) {
12231                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12232                                   "Speaker Playback Volume",
12233                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12234                 if (err < 0)
12235                         return err;
12236         } else {
12237                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12238                 if (err < 0)
12239                         return err;
12240         }
12241         nid = cfg->hp_pins[0];
12242         if (nid) {
12243                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12244                 if (err < 0)
12245                         return err;
12246         }
12247
12248         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12249         if (nid == 0x16) {
12250                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12251                                   "Mono Playback Switch",
12252                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12253                 if (err < 0)
12254                         return err;
12255         }
12256         return 0;
12257 }
12258
12259 /* create playback/capture controls for input pins */
12260 static int alc268_auto_create_analog_input_ctls(struct alc_spec *spec,
12261                                                 const struct auto_pin_cfg *cfg)
12262 {
12263         struct hda_input_mux *imux = &spec->private_imux[0];
12264         int i, idx1;
12265
12266         for (i = 0; i < AUTO_PIN_LAST; i++) {
12267                 switch(cfg->input_pins[i]) {
12268                 case 0x18:
12269                         idx1 = 0;       /* Mic 1 */
12270                         break;
12271                 case 0x19:
12272                         idx1 = 1;       /* Mic 2 */
12273                         break;
12274                 case 0x1a:
12275                         idx1 = 2;       /* Line In */
12276                         break;
12277                 case 0x1c:
12278                         idx1 = 3;       /* CD */
12279                         break;
12280                 case 0x12:
12281                 case 0x13:
12282                         idx1 = 6;       /* digital mics */
12283                         break;
12284                 default:
12285                         continue;
12286                 }
12287                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
12288                 imux->items[imux->num_items].index = idx1;
12289                 imux->num_items++;
12290         }
12291         return 0;
12292 }
12293
12294 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12295 {
12296         struct alc_spec *spec = codec->spec;
12297         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12298         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12299         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12300         unsigned int    dac_vol1, dac_vol2;
12301
12302         if (speaker_nid) {
12303                 snd_hda_codec_write(codec, speaker_nid, 0,
12304                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12305                 snd_hda_codec_write(codec, 0x0f, 0,
12306                                     AC_VERB_SET_AMP_GAIN_MUTE,
12307                                     AMP_IN_UNMUTE(1));
12308                 snd_hda_codec_write(codec, 0x10, 0,
12309                                     AC_VERB_SET_AMP_GAIN_MUTE,
12310                                     AMP_IN_UNMUTE(1));
12311         } else {
12312                 snd_hda_codec_write(codec, 0x0f, 0,
12313                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12314                 snd_hda_codec_write(codec, 0x10, 0,
12315                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12316         }
12317
12318         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12319         if (line_nid == 0x14)
12320                 dac_vol2 = AMP_OUT_ZERO;
12321         else if (line_nid == 0x15)
12322                 dac_vol1 = AMP_OUT_ZERO;
12323         if (hp_nid == 0x14)
12324                 dac_vol2 = AMP_OUT_ZERO;
12325         else if (hp_nid == 0x15)
12326                 dac_vol1 = AMP_OUT_ZERO;
12327         if (line_nid != 0x16 || hp_nid != 0x16 ||
12328             spec->autocfg.line_out_pins[1] != 0x16 ||
12329             spec->autocfg.line_out_pins[2] != 0x16)
12330                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12331
12332         snd_hda_codec_write(codec, 0x02, 0,
12333                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12334         snd_hda_codec_write(codec, 0x03, 0,
12335                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12336 }
12337
12338 /* pcm configuration: identical with ALC880 */
12339 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12340 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12341 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12342 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12343
12344 /*
12345  * BIOS auto configuration
12346  */
12347 static int alc268_parse_auto_config(struct hda_codec *codec)
12348 {
12349         struct alc_spec *spec = codec->spec;
12350         int err;
12351         static hda_nid_t alc268_ignore[] = { 0 };
12352
12353         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12354                                            alc268_ignore);
12355         if (err < 0)
12356                 return err;
12357         if (!spec->autocfg.line_outs) {
12358                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12359                         spec->multiout.max_channels = 2;
12360                         spec->no_analog = 1;
12361                         goto dig_only;
12362                 }
12363                 return 0; /* can't find valid BIOS pin config */
12364         }
12365         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12366         if (err < 0)
12367                 return err;
12368         err = alc268_auto_create_analog_input_ctls(spec, &spec->autocfg);
12369         if (err < 0)
12370                 return err;
12371
12372         spec->multiout.max_channels = 2;
12373
12374  dig_only:
12375         /* digital only support output */
12376         if (spec->autocfg.dig_outs) {
12377                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12378                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12379         }
12380         if (spec->kctls.list)
12381                 add_mixer(spec, spec->kctls.list);
12382
12383         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12384                 add_mixer(spec, alc268_beep_mixer);
12385
12386         add_verb(spec, alc268_volume_init_verbs);
12387         spec->num_mux_defs = 1;
12388         spec->input_mux = &spec->private_imux[0];
12389
12390         err = alc_auto_add_mic_boost(codec);
12391         if (err < 0)
12392                 return err;
12393
12394         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12395
12396         return 1;
12397 }
12398
12399 #define alc268_auto_init_multi_out      alc882_auto_init_multi_out
12400 #define alc268_auto_init_hp_out         alc882_auto_init_hp_out
12401 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12402
12403 /* init callback for auto-configuration model -- overriding the default init */
12404 static void alc268_auto_init(struct hda_codec *codec)
12405 {
12406         struct alc_spec *spec = codec->spec;
12407         alc268_auto_init_multi_out(codec);
12408         alc268_auto_init_hp_out(codec);
12409         alc268_auto_init_mono_speaker_out(codec);
12410         alc268_auto_init_analog_input(codec);
12411         if (spec->unsol_event)
12412                 alc_inithook(codec);
12413 }
12414
12415 /*
12416  * configuration and preset
12417  */
12418 static const char *alc268_models[ALC268_MODEL_LAST] = {
12419         [ALC267_QUANTA_IL1]     = "quanta-il1",
12420         [ALC268_3ST]            = "3stack",
12421         [ALC268_TOSHIBA]        = "toshiba",
12422         [ALC268_ACER]           = "acer",
12423         [ALC268_ACER_DMIC]      = "acer-dmic",
12424         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12425         [ALC268_DELL]           = "dell",
12426         [ALC268_ZEPTO]          = "zepto",
12427 #ifdef CONFIG_SND_DEBUG
12428         [ALC268_TEST]           = "test",
12429 #endif
12430         [ALC268_AUTO]           = "auto",
12431 };
12432
12433 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12434         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12435         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12436         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12437         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12438         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12439         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12440                                                 ALC268_ACER_ASPIRE_ONE),
12441         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12442         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12443         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12444                            ALC268_TOSHIBA),
12445         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12446         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12447         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12448                            ALC268_TOSHIBA),
12449         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12450         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12451         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12452         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12453         {}
12454 };
12455
12456 static struct alc_config_preset alc268_presets[] = {
12457         [ALC267_QUANTA_IL1] = {
12458                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer },
12459                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12460                                 alc267_quanta_il1_verbs },
12461                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12462                 .dac_nids = alc268_dac_nids,
12463                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12464                 .adc_nids = alc268_adc_nids_alt,
12465                 .hp_nid = 0x03,
12466                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12467                 .channel_mode = alc268_modes,
12468                 .input_mux = &alc268_capture_source,
12469                 .unsol_event = alc267_quanta_il1_unsol_event,
12470                 .init_hook = alc267_quanta_il1_init_hook,
12471         },
12472         [ALC268_3ST] = {
12473                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12474                             alc268_beep_mixer },
12475                 .init_verbs = { alc268_base_init_verbs },
12476                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12477                 .dac_nids = alc268_dac_nids,
12478                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12479                 .adc_nids = alc268_adc_nids_alt,
12480                 .capsrc_nids = alc268_capsrc_nids,
12481                 .hp_nid = 0x03,
12482                 .dig_out_nid = ALC268_DIGOUT_NID,
12483                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12484                 .channel_mode = alc268_modes,
12485                 .input_mux = &alc268_capture_source,
12486         },
12487         [ALC268_TOSHIBA] = {
12488                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12489                             alc268_beep_mixer },
12490                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12491                                 alc268_toshiba_verbs },
12492                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12493                 .dac_nids = alc268_dac_nids,
12494                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12495                 .adc_nids = alc268_adc_nids_alt,
12496                 .capsrc_nids = alc268_capsrc_nids,
12497                 .hp_nid = 0x03,
12498                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12499                 .channel_mode = alc268_modes,
12500                 .input_mux = &alc268_capture_source,
12501                 .unsol_event = alc268_toshiba_unsol_event,
12502                 .init_hook = alc268_toshiba_init_hook,
12503         },
12504         [ALC268_ACER] = {
12505                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12506                             alc268_beep_mixer },
12507                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12508                                 alc268_acer_verbs },
12509                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12510                 .dac_nids = alc268_dac_nids,
12511                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12512                 .adc_nids = alc268_adc_nids_alt,
12513                 .capsrc_nids = alc268_capsrc_nids,
12514                 .hp_nid = 0x02,
12515                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12516                 .channel_mode = alc268_modes,
12517                 .input_mux = &alc268_acer_capture_source,
12518                 .unsol_event = alc268_acer_unsol_event,
12519                 .init_hook = alc268_acer_init_hook,
12520         },
12521         [ALC268_ACER_DMIC] = {
12522                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12523                             alc268_beep_mixer },
12524                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12525                                 alc268_acer_verbs },
12526                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12527                 .dac_nids = alc268_dac_nids,
12528                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12529                 .adc_nids = alc268_adc_nids_alt,
12530                 .capsrc_nids = alc268_capsrc_nids,
12531                 .hp_nid = 0x02,
12532                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12533                 .channel_mode = alc268_modes,
12534                 .input_mux = &alc268_acer_dmic_capture_source,
12535                 .unsol_event = alc268_acer_unsol_event,
12536                 .init_hook = alc268_acer_init_hook,
12537         },
12538         [ALC268_ACER_ASPIRE_ONE] = {
12539                 .mixers = { alc268_acer_aspire_one_mixer,
12540                             alc268_beep_mixer,
12541                             alc268_capture_alt_mixer },
12542                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12543                                 alc268_acer_aspire_one_verbs },
12544                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12545                 .dac_nids = alc268_dac_nids,
12546                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12547                 .adc_nids = alc268_adc_nids_alt,
12548                 .capsrc_nids = alc268_capsrc_nids,
12549                 .hp_nid = 0x03,
12550                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12551                 .channel_mode = alc268_modes,
12552                 .input_mux = &alc268_acer_lc_capture_source,
12553                 .unsol_event = alc268_acer_lc_unsol_event,
12554                 .init_hook = alc268_acer_lc_init_hook,
12555         },
12556         [ALC268_DELL] = {
12557                 .mixers = { alc268_dell_mixer, alc268_beep_mixer },
12558                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12559                                 alc268_dell_verbs },
12560                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12561                 .dac_nids = alc268_dac_nids,
12562                 .hp_nid = 0x02,
12563                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12564                 .channel_mode = alc268_modes,
12565                 .unsol_event = alc_sku_unsol_event,
12566                 .init_hook = alc268_dell_init_hook,
12567                 .input_mux = &alc268_capture_source,
12568         },
12569         [ALC268_ZEPTO] = {
12570                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12571                             alc268_beep_mixer },
12572                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12573                                 alc268_toshiba_verbs },
12574                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12575                 .dac_nids = alc268_dac_nids,
12576                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12577                 .adc_nids = alc268_adc_nids_alt,
12578                 .capsrc_nids = alc268_capsrc_nids,
12579                 .hp_nid = 0x03,
12580                 .dig_out_nid = ALC268_DIGOUT_NID,
12581                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12582                 .channel_mode = alc268_modes,
12583                 .input_mux = &alc268_capture_source,
12584                 .unsol_event = alc268_toshiba_unsol_event,
12585                 .init_hook = alc268_toshiba_init_hook
12586         },
12587 #ifdef CONFIG_SND_DEBUG
12588         [ALC268_TEST] = {
12589                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12590                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12591                                 alc268_volume_init_verbs },
12592                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12593                 .dac_nids = alc268_dac_nids,
12594                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12595                 .adc_nids = alc268_adc_nids_alt,
12596                 .capsrc_nids = alc268_capsrc_nids,
12597                 .hp_nid = 0x03,
12598                 .dig_out_nid = ALC268_DIGOUT_NID,
12599                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12600                 .channel_mode = alc268_modes,
12601                 .input_mux = &alc268_capture_source,
12602         },
12603 #endif
12604 };
12605
12606 static int patch_alc268(struct hda_codec *codec)
12607 {
12608         struct alc_spec *spec;
12609         int board_config;
12610         int i, has_beep, err;
12611
12612         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12613         if (spec == NULL)
12614                 return -ENOMEM;
12615
12616         codec->spec = spec;
12617
12618         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12619                                                   alc268_models,
12620                                                   alc268_cfg_tbl);
12621
12622         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12623                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12624                        codec->chip_name);
12625                 board_config = ALC268_AUTO;
12626         }
12627
12628         if (board_config == ALC268_AUTO) {
12629                 /* automatic parse from the BIOS config */
12630                 err = alc268_parse_auto_config(codec);
12631                 if (err < 0) {
12632                         alc_free(codec);
12633                         return err;
12634                 } else if (!err) {
12635                         printk(KERN_INFO
12636                                "hda_codec: Cannot set up configuration "
12637                                "from BIOS.  Using base mode...\n");
12638                         board_config = ALC268_3ST;
12639                 }
12640         }
12641
12642         if (board_config != ALC268_AUTO)
12643                 setup_preset(spec, &alc268_presets[board_config]);
12644
12645         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12646         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12647         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12648
12649         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12650
12651         has_beep = 0;
12652         for (i = 0; i < spec->num_mixers; i++) {
12653                 if (spec->mixers[i] == alc268_beep_mixer) {
12654                         has_beep = 1;
12655                         break;
12656                 }
12657         }
12658
12659         if (has_beep) {
12660                 err = snd_hda_attach_beep_device(codec, 0x1);
12661                 if (err < 0) {
12662                         alc_free(codec);
12663                         return err;
12664                 }
12665                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12666                         /* override the amp caps for beep generator */
12667                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12668                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12669                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12670                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12671                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12672         }
12673
12674         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12675                 /* check whether NID 0x07 is valid */
12676                 unsigned int wcap = get_wcaps(codec, 0x07);
12677                 int i;
12678
12679                 /* get type */
12680                 wcap = get_wcaps_type(wcap);
12681                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12682                         spec->adc_nids = alc268_adc_nids_alt;
12683                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12684                         add_mixer(spec, alc268_capture_alt_mixer);
12685                 } else {
12686                         spec->adc_nids = alc268_adc_nids;
12687                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12688                         add_mixer(spec, alc268_capture_mixer);
12689                 }
12690                 spec->capsrc_nids = alc268_capsrc_nids;
12691                 /* set default input source */
12692                 for (i = 0; i < spec->num_adc_nids; i++)
12693                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12694                                 0, AC_VERB_SET_CONNECT_SEL,
12695                                 spec->input_mux->items[0].index);
12696         }
12697
12698         spec->vmaster_nid = 0x02;
12699
12700         codec->patch_ops = alc_patch_ops;
12701         if (board_config == ALC268_AUTO)
12702                 spec->init_hook = alc268_auto_init;
12703
12704         codec->proc_widget_hook = print_realtek_coef;
12705
12706         return 0;
12707 }
12708
12709 /*
12710  *  ALC269 channel source setting (2 channel)
12711  */
12712 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12713
12714 #define alc269_dac_nids         alc260_dac_nids
12715
12716 static hda_nid_t alc269_adc_nids[1] = {
12717         /* ADC1 */
12718         0x08,
12719 };
12720
12721 static hda_nid_t alc269_capsrc_nids[1] = {
12722         0x23,
12723 };
12724
12725 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12726  *       not a mux!
12727  */
12728
12729 static struct hda_input_mux alc269_eeepc_dmic_capture_source = {
12730         .num_items = 2,
12731         .items = {
12732                 { "i-Mic", 0x5 },
12733                 { "e-Mic", 0x0 },
12734         },
12735 };
12736
12737 static struct hda_input_mux alc269_eeepc_amic_capture_source = {
12738         .num_items = 2,
12739         .items = {
12740                 { "i-Mic", 0x1 },
12741                 { "e-Mic", 0x0 },
12742         },
12743 };
12744
12745 #define alc269_modes            alc260_modes
12746 #define alc269_capture_source   alc880_lg_lw_capture_source
12747
12748 static struct snd_kcontrol_new alc269_base_mixer[] = {
12749         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12750         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12751         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12752         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12753         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12754         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12755         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12756         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12757         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12758         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12759         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12760         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12761         { } /* end */
12762 };
12763
12764 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12765         /* output mixer control */
12766         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12767         {
12768                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12769                 .name = "Master Playback Switch",
12770                 .info = snd_hda_mixer_amp_switch_info,
12771                 .get = snd_hda_mixer_amp_switch_get,
12772                 .put = alc268_acer_master_sw_put,
12773                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12774         },
12775         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12776         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12777         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12778         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12779         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12780         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12781         { }
12782 };
12783
12784 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12785         /* output mixer control */
12786         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12787         {
12788                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12789                 .name = "Master Playback Switch",
12790                 .info = snd_hda_mixer_amp_switch_info,
12791                 .get = snd_hda_mixer_amp_switch_get,
12792                 .put = alc268_acer_master_sw_put,
12793                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12794         },
12795         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12796         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12797         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12798         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12799         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12800         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12801         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12802         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12803         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12804         { }
12805 };
12806
12807 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12808         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12809         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12810         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12811         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12812         { } /* end */
12813 };
12814
12815 /* capture mixer elements */
12816 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12817         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12818         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12819         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12820         { } /* end */
12821 };
12822
12823 /* FSC amilo */
12824 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
12825
12826 static struct hda_verb alc269_quanta_fl1_verbs[] = {
12827         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12828         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12829         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12830         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12831         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12832         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12833         { }
12834 };
12835
12836 static struct hda_verb alc269_lifebook_verbs[] = {
12837         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12838         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
12839         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12840         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12841         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12842         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12843         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12844         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12845         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12846         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12847         { }
12848 };
12849
12850 /* toggle speaker-output according to the hp-jack state */
12851 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
12852 {
12853         unsigned int present;
12854         unsigned char bits;
12855
12856         present = snd_hda_codec_read(codec, 0x15, 0,
12857                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12858         bits = present ? AMP_IN_MUTE(0) : 0;
12859         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12860                         AMP_IN_MUTE(0), bits);
12861         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12862                         AMP_IN_MUTE(0), bits);
12863
12864         snd_hda_codec_write(codec, 0x20, 0,
12865                         AC_VERB_SET_COEF_INDEX, 0x0c);
12866         snd_hda_codec_write(codec, 0x20, 0,
12867                         AC_VERB_SET_PROC_COEF, 0x680);
12868
12869         snd_hda_codec_write(codec, 0x20, 0,
12870                         AC_VERB_SET_COEF_INDEX, 0x0c);
12871         snd_hda_codec_write(codec, 0x20, 0,
12872                         AC_VERB_SET_PROC_COEF, 0x480);
12873 }
12874
12875 /* toggle speaker-output according to the hp-jacks state */
12876 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
12877 {
12878         unsigned int present;
12879         unsigned char bits;
12880
12881         /* Check laptop headphone socket */
12882         present = snd_hda_codec_read(codec, 0x15, 0,
12883                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12884
12885         /* Check port replicator headphone socket */
12886         present |= snd_hda_codec_read(codec, 0x1a, 0,
12887                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12888
12889         bits = present ? AMP_IN_MUTE(0) : 0;
12890         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
12891                         AMP_IN_MUTE(0), bits);
12892         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
12893                         AMP_IN_MUTE(0), bits);
12894
12895         snd_hda_codec_write(codec, 0x20, 0,
12896                         AC_VERB_SET_COEF_INDEX, 0x0c);
12897         snd_hda_codec_write(codec, 0x20, 0,
12898                         AC_VERB_SET_PROC_COEF, 0x680);
12899
12900         snd_hda_codec_write(codec, 0x20, 0,
12901                         AC_VERB_SET_COEF_INDEX, 0x0c);
12902         snd_hda_codec_write(codec, 0x20, 0,
12903                         AC_VERB_SET_PROC_COEF, 0x480);
12904 }
12905
12906 static void alc269_quanta_fl1_mic_automute(struct hda_codec *codec)
12907 {
12908         unsigned int present;
12909
12910         present = snd_hda_codec_read(codec, 0x18, 0,
12911                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12912         snd_hda_codec_write(codec, 0x23, 0,
12913                             AC_VERB_SET_CONNECT_SEL, present ? 0x0 : 0x1);
12914 }
12915
12916 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
12917 {
12918         unsigned int present_laptop;
12919         unsigned int present_dock;
12920
12921         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
12922                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12923
12924         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
12925                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12926
12927         /* Laptop mic port overrides dock mic port, design decision */
12928         if (present_dock)
12929                 snd_hda_codec_write(codec, 0x23, 0,
12930                                 AC_VERB_SET_CONNECT_SEL, 0x3);
12931         if (present_laptop)
12932                 snd_hda_codec_write(codec, 0x23, 0,
12933                                 AC_VERB_SET_CONNECT_SEL, 0x0);
12934         if (!present_dock && !present_laptop)
12935                 snd_hda_codec_write(codec, 0x23, 0,
12936                                 AC_VERB_SET_CONNECT_SEL, 0x1);
12937 }
12938
12939 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
12940                                     unsigned int res)
12941 {
12942         if ((res >> 26) == ALC880_HP_EVENT)
12943                 alc269_quanta_fl1_speaker_automute(codec);
12944         if ((res >> 26) == ALC880_MIC_EVENT)
12945                 alc269_quanta_fl1_mic_automute(codec);
12946 }
12947
12948 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
12949                                         unsigned int res)
12950 {
12951         if ((res >> 26) == ALC880_HP_EVENT)
12952                 alc269_lifebook_speaker_automute(codec);
12953         if ((res >> 26) == ALC880_MIC_EVENT)
12954                 alc269_lifebook_mic_autoswitch(codec);
12955 }
12956
12957 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
12958 {
12959         alc269_quanta_fl1_speaker_automute(codec);
12960         alc269_quanta_fl1_mic_automute(codec);
12961 }
12962
12963 static void alc269_lifebook_init_hook(struct hda_codec *codec)
12964 {
12965         alc269_lifebook_speaker_automute(codec);
12966         alc269_lifebook_mic_autoswitch(codec);
12967 }
12968
12969 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
12970         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12971         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
12972         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12973         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
12974         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12975         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12976         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12977         {}
12978 };
12979
12980 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
12981         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12982         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
12983         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
12984         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
12985         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12986         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12987         {}
12988 };
12989
12990 /* toggle speaker-output according to the hp-jack state */
12991 static void alc269_speaker_automute(struct hda_codec *codec)
12992 {
12993         unsigned int present;
12994         unsigned char bits;
12995
12996         present = snd_hda_codec_read(codec, 0x15, 0,
12997                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12998         bits = present ? AMP_IN_MUTE(0) : 0;
12999         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13000                                 AMP_IN_MUTE(0), bits);
13001         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13002                                 AMP_IN_MUTE(0), bits);
13003 }
13004
13005 static void alc269_eeepc_dmic_automute(struct hda_codec *codec)
13006 {
13007         unsigned int present;
13008
13009         present = snd_hda_codec_read(codec, 0x18, 0,
13010                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13011         snd_hda_codec_write(codec, 0x23, 0,
13012                                 AC_VERB_SET_CONNECT_SEL,  (present ? 0 : 5));
13013 }
13014
13015 static void alc269_eeepc_amic_automute(struct hda_codec *codec)
13016 {
13017         unsigned int present;
13018
13019         present = snd_hda_codec_read(codec, 0x18, 0,
13020                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13021         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13022                                 0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
13023         snd_hda_codec_write(codec, 0x24, 0, AC_VERB_SET_AMP_GAIN_MUTE,
13024                                 0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
13025 }
13026
13027 /* unsolicited event for HP jack sensing */
13028 static void alc269_eeepc_dmic_unsol_event(struct hda_codec *codec,
13029                                      unsigned int res)
13030 {
13031         if ((res >> 26) == ALC880_HP_EVENT)
13032                 alc269_speaker_automute(codec);
13033
13034         if ((res >> 26) == ALC880_MIC_EVENT)
13035                 alc269_eeepc_dmic_automute(codec);
13036 }
13037
13038 static void alc269_eeepc_dmic_inithook(struct hda_codec *codec)
13039 {
13040         alc269_speaker_automute(codec);
13041         alc269_eeepc_dmic_automute(codec);
13042 }
13043
13044 /* unsolicited event for HP jack sensing */
13045 static void alc269_eeepc_amic_unsol_event(struct hda_codec *codec,
13046                                      unsigned int res)
13047 {
13048         if ((res >> 26) == ALC880_HP_EVENT)
13049                 alc269_speaker_automute(codec);
13050
13051         if ((res >> 26) == ALC880_MIC_EVENT)
13052                 alc269_eeepc_amic_automute(codec);
13053 }
13054
13055 static void alc269_eeepc_amic_inithook(struct hda_codec *codec)
13056 {
13057         alc269_speaker_automute(codec);
13058         alc269_eeepc_amic_automute(codec);
13059 }
13060
13061 /*
13062  * generic initialization of ADC, input mixers and output mixers
13063  */
13064 static struct hda_verb alc269_init_verbs[] = {
13065         /*
13066          * Unmute ADC0 and set the default input to mic-in
13067          */
13068         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13069
13070         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13071          * analog-loopback mixer widget
13072          * Note: PASD motherboards uses the Line In 2 as the input for
13073          * front panel mic (mic 2)
13074          */
13075         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13076         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13077         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13078         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13079         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13080         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13081
13082         /*
13083          * Set up output mixers (0x0c - 0x0e)
13084          */
13085         /* set vol=0 to output mixers */
13086         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13087         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13088
13089         /* set up input amps for analog loopback */
13090         /* Amp Indices: DAC = 0, mixer = 1 */
13091         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13092         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13093         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13094         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13095         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13096         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13097
13098         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13099         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13100         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13101         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13102         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13103         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13104         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13105
13106         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13107         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13108         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13109         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13110         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13111         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13112         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13113
13114         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13115         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13116
13117         /* FIXME: use matrix-type input source selection */
13118         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13119         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13120         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13121         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13122         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13123         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13124
13125         /* set EAPD */
13126         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13127         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13128         { }
13129 };
13130
13131 /* add playback controls from the parsed DAC table */
13132 static int alc269_auto_create_multi_out_ctls(struct alc_spec *spec,
13133                                              const struct auto_pin_cfg *cfg)
13134 {
13135         hda_nid_t nid;
13136         int err;
13137
13138         spec->multiout.num_dacs = 1;    /* only use one dac */
13139         spec->multiout.dac_nids = spec->private_dac_nids;
13140         spec->multiout.dac_nids[0] = 2;
13141
13142         nid = cfg->line_out_pins[0];
13143         if (nid) {
13144                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
13145                                   "Front Playback Volume",
13146                                   HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT));
13147                 if (err < 0)
13148                         return err;
13149                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13150                                   "Front Playback Switch",
13151                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
13152                 if (err < 0)
13153                         return err;
13154         }
13155
13156         nid = cfg->speaker_pins[0];
13157         if (nid) {
13158                 if (!cfg->line_out_pins[0]) {
13159                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13160                                           "Speaker Playback Volume",
13161                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
13162                                                               HDA_OUTPUT));
13163                         if (err < 0)
13164                                 return err;
13165                 }
13166                 if (nid == 0x16) {
13167                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13168                                           "Speaker Playback Switch",
13169                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13170                                                               HDA_OUTPUT));
13171                         if (err < 0)
13172                                 return err;
13173                 } else {
13174                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13175                                           "Speaker Playback Switch",
13176                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13177                                                               HDA_OUTPUT));
13178                         if (err < 0)
13179                                 return err;
13180                 }
13181         }
13182         nid = cfg->hp_pins[0];
13183         if (nid) {
13184                 /* spec->multiout.hp_nid = 2; */
13185                 if (!cfg->line_out_pins[0] && !cfg->speaker_pins[0]) {
13186                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
13187                                           "Headphone Playback Volume",
13188                                           HDA_COMPOSE_AMP_VAL(0x02, 3, 0,
13189                                                               HDA_OUTPUT));
13190                         if (err < 0)
13191                                 return err;
13192                 }
13193                 if (nid == 0x16) {
13194                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13195                                           "Headphone Playback Switch",
13196                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
13197                                                               HDA_OUTPUT));
13198                         if (err < 0)
13199                                 return err;
13200                 } else {
13201                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
13202                                           "Headphone Playback Switch",
13203                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
13204                                                               HDA_OUTPUT));
13205                         if (err < 0)
13206                                 return err;
13207                 }
13208         }
13209         return 0;
13210 }
13211
13212 #define alc269_auto_create_analog_input_ctls \
13213         alc262_auto_create_analog_input_ctls
13214
13215 #ifdef CONFIG_SND_HDA_POWER_SAVE
13216 #define alc269_loopbacks        alc880_loopbacks
13217 #endif
13218
13219 /* pcm configuration: identical with ALC880 */
13220 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13221 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13222 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13223 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13224
13225 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13226         .substreams = 1,
13227         .channels_min = 2,
13228         .channels_max = 8,
13229         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13230         /* NID is set in alc_build_pcms */
13231         .ops = {
13232                 .open = alc880_playback_pcm_open,
13233                 .prepare = alc880_playback_pcm_prepare,
13234                 .cleanup = alc880_playback_pcm_cleanup
13235         },
13236 };
13237
13238 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13239         .substreams = 1,
13240         .channels_min = 2,
13241         .channels_max = 2,
13242         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13243         /* NID is set in alc_build_pcms */
13244 };
13245
13246 /*
13247  * BIOS auto configuration
13248  */
13249 static int alc269_parse_auto_config(struct hda_codec *codec)
13250 {
13251         struct alc_spec *spec = codec->spec;
13252         int err;
13253         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13254
13255         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13256                                            alc269_ignore);
13257         if (err < 0)
13258                 return err;
13259
13260         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13261         if (err < 0)
13262                 return err;
13263         err = alc269_auto_create_analog_input_ctls(spec, &spec->autocfg);
13264         if (err < 0)
13265                 return err;
13266
13267         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13268
13269         if (spec->autocfg.dig_outs)
13270                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13271
13272         if (spec->kctls.list)
13273                 add_mixer(spec, spec->kctls.list);
13274
13275         add_verb(spec, alc269_init_verbs);
13276         spec->num_mux_defs = 1;
13277         spec->input_mux = &spec->private_imux[0];
13278         /* set default input source */
13279         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13280                                   0, AC_VERB_SET_CONNECT_SEL,
13281                                   spec->input_mux->items[0].index);
13282
13283         err = alc_auto_add_mic_boost(codec);
13284         if (err < 0)
13285                 return err;
13286
13287         if (!spec->cap_mixer && !spec->no_analog)
13288                 set_capture_mixer(spec);
13289
13290         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13291
13292         return 1;
13293 }
13294
13295 #define alc269_auto_init_multi_out      alc882_auto_init_multi_out
13296 #define alc269_auto_init_hp_out         alc882_auto_init_hp_out
13297 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13298
13299
13300 /* init callback for auto-configuration model -- overriding the default init */
13301 static void alc269_auto_init(struct hda_codec *codec)
13302 {
13303         struct alc_spec *spec = codec->spec;
13304         alc269_auto_init_multi_out(codec);
13305         alc269_auto_init_hp_out(codec);
13306         alc269_auto_init_analog_input(codec);
13307         if (spec->unsol_event)
13308                 alc_inithook(codec);
13309 }
13310
13311 /*
13312  * configuration and preset
13313  */
13314 static const char *alc269_models[ALC269_MODEL_LAST] = {
13315         [ALC269_BASIC]                  = "basic",
13316         [ALC269_QUANTA_FL1]             = "quanta",
13317         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
13318         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
13319         [ALC269_FUJITSU]                = "fujitsu",
13320         [ALC269_LIFEBOOK]               = "lifebook"
13321 };
13322
13323 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13324         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13325         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13326                       ALC269_ASUS_EEEPC_P703),
13327         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13328         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13329         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13330         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13331         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13332         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13333         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13334                       ALC269_ASUS_EEEPC_P901),
13335         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13336                       ALC269_ASUS_EEEPC_P901),
13337         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13338         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13339         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13340         {}
13341 };
13342
13343 static struct alc_config_preset alc269_presets[] = {
13344         [ALC269_BASIC] = {
13345                 .mixers = { alc269_base_mixer },
13346                 .init_verbs = { alc269_init_verbs },
13347                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13348                 .dac_nids = alc269_dac_nids,
13349                 .hp_nid = 0x03,
13350                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13351                 .channel_mode = alc269_modes,
13352                 .input_mux = &alc269_capture_source,
13353         },
13354         [ALC269_QUANTA_FL1] = {
13355                 .mixers = { alc269_quanta_fl1_mixer },
13356                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13357                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13358                 .dac_nids = alc269_dac_nids,
13359                 .hp_nid = 0x03,
13360                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13361                 .channel_mode = alc269_modes,
13362                 .input_mux = &alc269_capture_source,
13363                 .unsol_event = alc269_quanta_fl1_unsol_event,
13364                 .init_hook = alc269_quanta_fl1_init_hook,
13365         },
13366         [ALC269_ASUS_EEEPC_P703] = {
13367                 .mixers = { alc269_eeepc_mixer },
13368                 .cap_mixer = alc269_epc_capture_mixer,
13369                 .init_verbs = { alc269_init_verbs,
13370                                 alc269_eeepc_amic_init_verbs },
13371                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13372                 .dac_nids = alc269_dac_nids,
13373                 .hp_nid = 0x03,
13374                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13375                 .channel_mode = alc269_modes,
13376                 .input_mux = &alc269_eeepc_amic_capture_source,
13377                 .unsol_event = alc269_eeepc_amic_unsol_event,
13378                 .init_hook = alc269_eeepc_amic_inithook,
13379         },
13380         [ALC269_ASUS_EEEPC_P901] = {
13381                 .mixers = { alc269_eeepc_mixer },
13382                 .cap_mixer = alc269_epc_capture_mixer,
13383                 .init_verbs = { alc269_init_verbs,
13384                                 alc269_eeepc_dmic_init_verbs },
13385                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13386                 .dac_nids = alc269_dac_nids,
13387                 .hp_nid = 0x03,
13388                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13389                 .channel_mode = alc269_modes,
13390                 .input_mux = &alc269_eeepc_dmic_capture_source,
13391                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13392                 .init_hook = alc269_eeepc_dmic_inithook,
13393         },
13394         [ALC269_FUJITSU] = {
13395                 .mixers = { alc269_fujitsu_mixer },
13396                 .cap_mixer = alc269_epc_capture_mixer,
13397                 .init_verbs = { alc269_init_verbs,
13398                                 alc269_eeepc_dmic_init_verbs },
13399                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13400                 .dac_nids = alc269_dac_nids,
13401                 .hp_nid = 0x03,
13402                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13403                 .channel_mode = alc269_modes,
13404                 .input_mux = &alc269_eeepc_dmic_capture_source,
13405                 .unsol_event = alc269_eeepc_dmic_unsol_event,
13406                 .init_hook = alc269_eeepc_dmic_inithook,
13407         },
13408         [ALC269_LIFEBOOK] = {
13409                 .mixers = { alc269_lifebook_mixer },
13410                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13411                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13412                 .dac_nids = alc269_dac_nids,
13413                 .hp_nid = 0x03,
13414                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13415                 .channel_mode = alc269_modes,
13416                 .input_mux = &alc269_capture_source,
13417                 .unsol_event = alc269_lifebook_unsol_event,
13418                 .init_hook = alc269_lifebook_init_hook,
13419         },
13420 };
13421
13422 static int patch_alc269(struct hda_codec *codec)
13423 {
13424         struct alc_spec *spec;
13425         int board_config;
13426         int err;
13427
13428         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13429         if (spec == NULL)
13430                 return -ENOMEM;
13431
13432         codec->spec = spec;
13433
13434         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13435
13436         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13437                                                   alc269_models,
13438                                                   alc269_cfg_tbl);
13439
13440         if (board_config < 0) {
13441                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13442                        codec->chip_name);
13443                 board_config = ALC269_AUTO;
13444         }
13445
13446         if (board_config == ALC269_AUTO) {
13447                 /* automatic parse from the BIOS config */
13448                 err = alc269_parse_auto_config(codec);
13449                 if (err < 0) {
13450                         alc_free(codec);
13451                         return err;
13452                 } else if (!err) {
13453                         printk(KERN_INFO
13454                                "hda_codec: Cannot set up configuration "
13455                                "from BIOS.  Using base mode...\n");
13456                         board_config = ALC269_BASIC;
13457                 }
13458         }
13459
13460         err = snd_hda_attach_beep_device(codec, 0x1);
13461         if (err < 0) {
13462                 alc_free(codec);
13463                 return err;
13464         }
13465
13466         if (board_config != ALC269_AUTO)
13467                 setup_preset(spec, &alc269_presets[board_config]);
13468
13469         if (codec->subsystem_id == 0x17aa3bf8) {
13470                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13471                  * fix the sample rate of analog I/O to 44.1kHz
13472                  */
13473                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13474                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13475         } else {
13476                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13477                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13478         }
13479         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13480         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13481
13482         spec->adc_nids = alc269_adc_nids;
13483         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13484         spec->capsrc_nids = alc269_capsrc_nids;
13485         if (!spec->cap_mixer)
13486                 set_capture_mixer(spec);
13487         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13488
13489         spec->vmaster_nid = 0x02;
13490
13491         codec->patch_ops = alc_patch_ops;
13492         if (board_config == ALC269_AUTO)
13493                 spec->init_hook = alc269_auto_init;
13494 #ifdef CONFIG_SND_HDA_POWER_SAVE
13495         if (!spec->loopback.amplist)
13496                 spec->loopback.amplist = alc269_loopbacks;
13497 #endif
13498         codec->proc_widget_hook = print_realtek_coef;
13499
13500         return 0;
13501 }
13502
13503 /*
13504  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13505  */
13506
13507 /*
13508  * set the path ways for 2 channel output
13509  * need to set the codec line out and mic 1 pin widgets to inputs
13510  */
13511 static struct hda_verb alc861_threestack_ch2_init[] = {
13512         /* set pin widget 1Ah (line in) for input */
13513         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13514         /* set pin widget 18h (mic1/2) for input, for mic also enable
13515          * the vref
13516          */
13517         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13518
13519         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13520 #if 0
13521         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13522         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13523 #endif
13524         { } /* end */
13525 };
13526 /*
13527  * 6ch mode
13528  * need to set the codec line out and mic 1 pin widgets to outputs
13529  */
13530 static struct hda_verb alc861_threestack_ch6_init[] = {
13531         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13532         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13533         /* set pin widget 18h (mic1) for output (CLFE)*/
13534         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13535
13536         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13537         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13538
13539         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13540 #if 0
13541         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13542         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13543 #endif
13544         { } /* end */
13545 };
13546
13547 static struct hda_channel_mode alc861_threestack_modes[2] = {
13548         { 2, alc861_threestack_ch2_init },
13549         { 6, alc861_threestack_ch6_init },
13550 };
13551 /* Set mic1 as input and unmute the mixer */
13552 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13553         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13554         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13555         { } /* end */
13556 };
13557 /* Set mic1 as output and mute mixer */
13558 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13559         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13560         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13561         { } /* end */
13562 };
13563
13564 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13565         { 2, alc861_uniwill_m31_ch2_init },
13566         { 4, alc861_uniwill_m31_ch4_init },
13567 };
13568
13569 /* Set mic1 and line-in as input and unmute the mixer */
13570 static struct hda_verb alc861_asus_ch2_init[] = {
13571         /* set pin widget 1Ah (line in) for input */
13572         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13573         /* set pin widget 18h (mic1/2) for input, for mic also enable
13574          * the vref
13575          */
13576         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13577
13578         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13579 #if 0
13580         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13581         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13582 #endif
13583         { } /* end */
13584 };
13585 /* Set mic1 nad line-in as output and mute mixer */
13586 static struct hda_verb alc861_asus_ch6_init[] = {
13587         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13588         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13589         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13590         /* set pin widget 18h (mic1) for output (CLFE)*/
13591         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13592         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13593         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13594         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13595
13596         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13597 #if 0
13598         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13599         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13600 #endif
13601         { } /* end */
13602 };
13603
13604 static struct hda_channel_mode alc861_asus_modes[2] = {
13605         { 2, alc861_asus_ch2_init },
13606         { 6, alc861_asus_ch6_init },
13607 };
13608
13609 /* patch-ALC861 */
13610
13611 static struct snd_kcontrol_new alc861_base_mixer[] = {
13612         /* output mixer control */
13613         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13614         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13615         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13616         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13617         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13618
13619         /*Input mixer control */
13620         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13621            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13622         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13623         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13624         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13625         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13626         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13627         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13628         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13629         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13630
13631         { } /* end */
13632 };
13633
13634 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13635         /* output mixer control */
13636         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13637         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13638         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13639         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13640         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13641
13642         /* Input mixer control */
13643         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13644            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13645         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13646         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13647         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13648         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13649         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13650         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13651         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13652         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13653
13654         {
13655                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13656                 .name = "Channel Mode",
13657                 .info = alc_ch_mode_info,
13658                 .get = alc_ch_mode_get,
13659                 .put = alc_ch_mode_put,
13660                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13661         },
13662         { } /* end */
13663 };
13664
13665 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13666         /* output mixer control */
13667         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13668         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13669         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13670
13671         { } /* end */
13672 };
13673
13674 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13675         /* output mixer control */
13676         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13677         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13678         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13679         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13680         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13681
13682         /* Input mixer control */
13683         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13684            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13685         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13686         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13687         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13688         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13689         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13690         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13691         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13692         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13693
13694         {
13695                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13696                 .name = "Channel Mode",
13697                 .info = alc_ch_mode_info,
13698                 .get = alc_ch_mode_get,
13699                 .put = alc_ch_mode_put,
13700                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13701         },
13702         { } /* end */
13703 };
13704
13705 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13706         /* output mixer control */
13707         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13708         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13709         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13710         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13711         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13712
13713         /* Input mixer control */
13714         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13715         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13716         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13717         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13718         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13719         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13720         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13721         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13722         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13723         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13724
13725         {
13726                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13727                 .name = "Channel Mode",
13728                 .info = alc_ch_mode_info,
13729                 .get = alc_ch_mode_get,
13730                 .put = alc_ch_mode_put,
13731                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13732         },
13733         { }
13734 };
13735
13736 /* additional mixer */
13737 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13738         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13739         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13740         { }
13741 };
13742
13743 /*
13744  * generic initialization of ADC, input mixers and output mixers
13745  */
13746 static struct hda_verb alc861_base_init_verbs[] = {
13747         /*
13748          * Unmute ADC0 and set the default input to mic-in
13749          */
13750         /* port-A for surround (rear panel) */
13751         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13752         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13753         /* port-B for mic-in (rear panel) with vref */
13754         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13755         /* port-C for line-in (rear panel) */
13756         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13757         /* port-D for Front */
13758         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13759         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13760         /* port-E for HP out (front panel) */
13761         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13762         /* route front PCM to HP */
13763         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13764         /* port-F for mic-in (front panel) with vref */
13765         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13766         /* port-G for CLFE (rear panel) */
13767         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13768         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13769         /* port-H for side (rear panel) */
13770         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13771         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13772         /* CD-in */
13773         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13774         /* route front mic to ADC1*/
13775         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13776         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13777
13778         /* Unmute DAC0~3 & spdif out*/
13779         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13780         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13781         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13782         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13783         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13784
13785         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13786         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13787         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13788         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13789         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13790
13791         /* Unmute Stereo Mixer 15 */
13792         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13793         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13794         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13795         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13796
13797         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13798         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13799         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13800         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13801         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13802         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13803         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13804         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13805         /* hp used DAC 3 (Front) */
13806         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13807         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13808
13809         { }
13810 };
13811
13812 static struct hda_verb alc861_threestack_init_verbs[] = {
13813         /*
13814          * Unmute ADC0 and set the default input to mic-in
13815          */
13816         /* port-A for surround (rear panel) */
13817         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13818         /* port-B for mic-in (rear panel) with vref */
13819         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13820         /* port-C for line-in (rear panel) */
13821         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13822         /* port-D for Front */
13823         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13824         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13825         /* port-E for HP out (front panel) */
13826         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13827         /* route front PCM to HP */
13828         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13829         /* port-F for mic-in (front panel) with vref */
13830         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13831         /* port-G for CLFE (rear panel) */
13832         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13833         /* port-H for side (rear panel) */
13834         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13835         /* CD-in */
13836         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13837         /* route front mic to ADC1*/
13838         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13839         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13840         /* Unmute DAC0~3 & spdif out*/
13841         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13842         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13843         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13844         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13845         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13846
13847         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13848         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13849         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13850         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13851         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13852
13853         /* Unmute Stereo Mixer 15 */
13854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13855         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13856         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13857         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13858
13859         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13860         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13861         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13862         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13863         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13864         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13865         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13866         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13867         /* hp used DAC 3 (Front) */
13868         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13869         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13870         { }
13871 };
13872
13873 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13874         /*
13875          * Unmute ADC0 and set the default input to mic-in
13876          */
13877         /* port-A for surround (rear panel) */
13878         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13879         /* port-B for mic-in (rear panel) with vref */
13880         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13881         /* port-C for line-in (rear panel) */
13882         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13883         /* port-D for Front */
13884         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13885         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13886         /* port-E for HP out (front panel) */
13887         /* this has to be set to VREF80 */
13888         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13889         /* route front PCM to HP */
13890         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13891         /* port-F for mic-in (front panel) with vref */
13892         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13893         /* port-G for CLFE (rear panel) */
13894         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13895         /* port-H for side (rear panel) */
13896         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13897         /* CD-in */
13898         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13899         /* route front mic to ADC1*/
13900         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13901         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13902         /* Unmute DAC0~3 & spdif out*/
13903         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13904         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13905         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13906         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13907         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13908
13909         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13910         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13911         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13912         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13913         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13914
13915         /* Unmute Stereo Mixer 15 */
13916         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13917         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13918         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13919         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13920
13921         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13922         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13923         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13924         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13925         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13926         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13927         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13928         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13929         /* hp used DAC 3 (Front) */
13930         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13931         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13932         { }
13933 };
13934
13935 static struct hda_verb alc861_asus_init_verbs[] = {
13936         /*
13937          * Unmute ADC0 and set the default input to mic-in
13938          */
13939         /* port-A for surround (rear panel)
13940          * according to codec#0 this is the HP jack
13941          */
13942         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
13943         /* route front PCM to HP */
13944         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
13945         /* port-B for mic-in (rear panel) with vref */
13946         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13947         /* port-C for line-in (rear panel) */
13948         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13949         /* port-D for Front */
13950         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13951         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13952         /* port-E for HP out (front panel) */
13953         /* this has to be set to VREF80 */
13954         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13955         /* route front PCM to HP */
13956         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13957         /* port-F for mic-in (front panel) with vref */
13958         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13959         /* port-G for CLFE (rear panel) */
13960         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13961         /* port-H for side (rear panel) */
13962         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13963         /* CD-in */
13964         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13965         /* route front mic to ADC1*/
13966         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13967         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13968         /* Unmute DAC0~3 & spdif out*/
13969         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13970         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13971         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13972         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13973         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13974         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13975         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13976         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13977         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13978         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13979
13980         /* Unmute Stereo Mixer 15 */
13981         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13982         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13983         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13984         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13985
13986         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13987         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13988         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13989         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13990         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13991         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13992         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13993         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13994         /* hp used DAC 3 (Front) */
13995         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13996         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13997         { }
13998 };
13999
14000 /* additional init verbs for ASUS laptops */
14001 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14002         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14003         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14004         { }
14005 };
14006
14007 /*
14008  * generic initialization of ADC, input mixers and output mixers
14009  */
14010 static struct hda_verb alc861_auto_init_verbs[] = {
14011         /*
14012          * Unmute ADC0 and set the default input to mic-in
14013          */
14014         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14015         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14016
14017         /* Unmute DAC0~3 & spdif out*/
14018         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14019         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14020         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14021         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14022         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14023
14024         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14025         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14026         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14027         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14028         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14029
14030         /* Unmute Stereo Mixer 15 */
14031         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14032         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14033         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14034         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14035
14036         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14037         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14038         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14039         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14040         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14041         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14042         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14043         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14044
14045         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14046         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14047         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14048         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14049         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14050         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14051         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14052         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14053
14054         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14055
14056         { }
14057 };
14058
14059 static struct hda_verb alc861_toshiba_init_verbs[] = {
14060         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14061
14062         { }
14063 };
14064
14065 /* toggle speaker-output according to the hp-jack state */
14066 static void alc861_toshiba_automute(struct hda_codec *codec)
14067 {
14068         unsigned int present;
14069
14070         present = snd_hda_codec_read(codec, 0x0f, 0,
14071                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14072         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14073                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14074         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14075                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14076 }
14077
14078 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14079                                        unsigned int res)
14080 {
14081         if ((res >> 26) == ALC880_HP_EVENT)
14082                 alc861_toshiba_automute(codec);
14083 }
14084
14085 /* pcm configuration: identical with ALC880 */
14086 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14087 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14088 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14089 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14090
14091
14092 #define ALC861_DIGOUT_NID       0x07
14093
14094 static struct hda_channel_mode alc861_8ch_modes[1] = {
14095         { 8, NULL }
14096 };
14097
14098 static hda_nid_t alc861_dac_nids[4] = {
14099         /* front, surround, clfe, side */
14100         0x03, 0x06, 0x05, 0x04
14101 };
14102
14103 static hda_nid_t alc660_dac_nids[3] = {
14104         /* front, clfe, surround */
14105         0x03, 0x05, 0x06
14106 };
14107
14108 static hda_nid_t alc861_adc_nids[1] = {
14109         /* ADC0-2 */
14110         0x08,
14111 };
14112
14113 static struct hda_input_mux alc861_capture_source = {
14114         .num_items = 5,
14115         .items = {
14116                 { "Mic", 0x0 },
14117                 { "Front Mic", 0x3 },
14118                 { "Line", 0x1 },
14119                 { "CD", 0x4 },
14120                 { "Mixer", 0x5 },
14121         },
14122 };
14123
14124 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14125 {
14126         struct alc_spec *spec = codec->spec;
14127         hda_nid_t mix, srcs[5];
14128         int i, j, num;
14129
14130         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14131                 return 0;
14132         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14133         if (num < 0)
14134                 return 0;
14135         for (i = 0; i < num; i++) {
14136                 unsigned int type;
14137                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14138                 if (type != AC_WID_AUD_OUT)
14139                         continue;
14140                 for (j = 0; j < spec->multiout.num_dacs; j++)
14141                         if (spec->multiout.dac_nids[j] == srcs[i])
14142                                 break;
14143                 if (j >= spec->multiout.num_dacs)
14144                         return srcs[i];
14145         }
14146         return 0;
14147 }
14148
14149 /* fill in the dac_nids table from the parsed pin configuration */
14150 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14151                                      const struct auto_pin_cfg *cfg)
14152 {
14153         struct alc_spec *spec = codec->spec;
14154         int i;
14155         hda_nid_t nid, dac;
14156
14157         spec->multiout.dac_nids = spec->private_dac_nids;
14158         for (i = 0; i < cfg->line_outs; i++) {
14159                 nid = cfg->line_out_pins[i];
14160                 dac = alc861_look_for_dac(codec, nid);
14161                 if (!dac)
14162                         continue;
14163                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14164         }
14165         return 0;
14166 }
14167
14168 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14169                                 hda_nid_t nid, unsigned int chs)
14170 {
14171         char name[32];
14172         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
14173         return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name,
14174                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14175 }
14176
14177 /* add playback controls from the parsed DAC table */
14178 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14179                                              const struct auto_pin_cfg *cfg)
14180 {
14181         struct alc_spec *spec = codec->spec;
14182         static const char *chname[4] = {
14183                 "Front", "Surround", NULL /*CLFE*/, "Side"
14184         };
14185         hda_nid_t nid;
14186         int i, err;
14187
14188         if (cfg->line_outs == 1) {
14189                 const char *pfx = NULL;
14190                 if (!cfg->hp_outs)
14191                         pfx = "Master";
14192                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14193                         pfx = "Speaker";
14194                 if (pfx) {
14195                         nid = spec->multiout.dac_nids[0];
14196                         return alc861_create_out_sw(codec, pfx, nid, 3);
14197                 }
14198         }
14199
14200         for (i = 0; i < cfg->line_outs; i++) {
14201                 nid = spec->multiout.dac_nids[i];
14202                 if (!nid)
14203                         continue;
14204                 if (i == 2) {
14205                         /* Center/LFE */
14206                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14207                         if (err < 0)
14208                                 return err;
14209                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14210                         if (err < 0)
14211                                 return err;
14212                 } else {
14213                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14214                         if (err < 0)
14215                                 return err;
14216                 }
14217         }
14218         return 0;
14219 }
14220
14221 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14222 {
14223         struct alc_spec *spec = codec->spec;
14224         int err;
14225         hda_nid_t nid;
14226
14227         if (!pin)
14228                 return 0;
14229
14230         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14231                 nid = alc861_look_for_dac(codec, pin);
14232                 if (nid) {
14233                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14234                         if (err < 0)
14235                                 return err;
14236                         spec->multiout.hp_nid = nid;
14237                 }
14238         }
14239         return 0;
14240 }
14241
14242 /* create playback/capture controls for input pins */
14243 static int alc861_auto_create_analog_input_ctls(struct hda_codec *codec,
14244                                                 const struct auto_pin_cfg *cfg)
14245 {
14246         struct alc_spec *spec = codec->spec;
14247         struct hda_input_mux *imux = &spec->private_imux[0];
14248         int i, err, idx, idx1;
14249
14250         for (i = 0; i < AUTO_PIN_LAST; i++) {
14251                 switch (cfg->input_pins[i]) {
14252                 case 0x0c:
14253                         idx1 = 1;
14254                         idx = 2;        /* Line In */
14255                         break;
14256                 case 0x0f:
14257                         idx1 = 2;
14258                         idx = 2;        /* Line In */
14259                         break;
14260                 case 0x0d:
14261                         idx1 = 0;
14262                         idx = 1;        /* Mic In */
14263                         break;
14264                 case 0x10:
14265                         idx1 = 3;
14266                         idx = 1;        /* Mic In */
14267                         break;
14268                 case 0x11:
14269                         idx1 = 4;
14270                         idx = 0;        /* CD */
14271                         break;
14272                 default:
14273                         continue;
14274                 }
14275
14276                 err = new_analog_input(spec, cfg->input_pins[i],
14277                                        auto_pin_cfg_labels[i], idx, 0x15);
14278                 if (err < 0)
14279                         return err;
14280
14281                 imux->items[imux->num_items].label = auto_pin_cfg_labels[i];
14282                 imux->items[imux->num_items].index = idx1;
14283                 imux->num_items++;
14284         }
14285         return 0;
14286 }
14287
14288 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14289                                               hda_nid_t nid,
14290                                               int pin_type, hda_nid_t dac)
14291 {
14292         hda_nid_t mix, srcs[5];
14293         int i, num;
14294
14295         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14296                             pin_type);
14297         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14298                             AMP_OUT_UNMUTE);
14299         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14300                 return;
14301         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14302         if (num < 0)
14303                 return;
14304         for (i = 0; i < num; i++) {
14305                 unsigned int mute;
14306                 if (srcs[i] == dac || srcs[i] == 0x15)
14307                         mute = AMP_IN_UNMUTE(i);
14308                 else
14309                         mute = AMP_IN_MUTE(i);
14310                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14311                                     mute);
14312         }
14313 }
14314
14315 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14316 {
14317         struct alc_spec *spec = codec->spec;
14318         int i;
14319
14320         for (i = 0; i < spec->autocfg.line_outs; i++) {
14321                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14322                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14323                 if (nid)
14324                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14325                                                           spec->multiout.dac_nids[i]);
14326         }
14327 }
14328
14329 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14330 {
14331         struct alc_spec *spec = codec->spec;
14332         hda_nid_t pin;
14333
14334         pin = spec->autocfg.hp_pins[0];
14335         if (pin)
14336                 alc861_auto_set_output_and_unmute(codec, pin, PIN_HP,
14337                                                   spec->multiout.hp_nid);
14338         pin = spec->autocfg.speaker_pins[0];
14339         if (pin)
14340                 alc861_auto_set_output_and_unmute(codec, pin, PIN_OUT,
14341                                                   spec->multiout.dac_nids[0]);
14342 }
14343
14344 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14345 {
14346         struct alc_spec *spec = codec->spec;
14347         int i;
14348
14349         for (i = 0; i < AUTO_PIN_LAST; i++) {
14350                 hda_nid_t nid = spec->autocfg.input_pins[i];
14351                 if (nid >= 0x0c && nid <= 0x11)
14352                         alc_set_input_pin(codec, nid, i);
14353         }
14354 }
14355
14356 /* parse the BIOS configuration and set up the alc_spec */
14357 /* return 1 if successful, 0 if the proper config is not found,
14358  * or a negative error code
14359  */
14360 static int alc861_parse_auto_config(struct hda_codec *codec)
14361 {
14362         struct alc_spec *spec = codec->spec;
14363         int err;
14364         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14365
14366         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14367                                            alc861_ignore);
14368         if (err < 0)
14369                 return err;
14370         if (!spec->autocfg.line_outs)
14371                 return 0; /* can't find valid BIOS pin config */
14372
14373         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14374         if (err < 0)
14375                 return err;
14376         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14377         if (err < 0)
14378                 return err;
14379         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14380         if (err < 0)
14381                 return err;
14382         err = alc861_auto_create_analog_input_ctls(codec, &spec->autocfg);
14383         if (err < 0)
14384                 return err;
14385
14386         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14387
14388         if (spec->autocfg.dig_outs)
14389                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14390
14391         if (spec->kctls.list)
14392                 add_mixer(spec, spec->kctls.list);
14393
14394         add_verb(spec, alc861_auto_init_verbs);
14395
14396         spec->num_mux_defs = 1;
14397         spec->input_mux = &spec->private_imux[0];
14398
14399         spec->adc_nids = alc861_adc_nids;
14400         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14401         set_capture_mixer(spec);
14402
14403         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14404
14405         return 1;
14406 }
14407
14408 /* additional initialization for auto-configuration model */
14409 static void alc861_auto_init(struct hda_codec *codec)
14410 {
14411         struct alc_spec *spec = codec->spec;
14412         alc861_auto_init_multi_out(codec);
14413         alc861_auto_init_hp_out(codec);
14414         alc861_auto_init_analog_input(codec);
14415         if (spec->unsol_event)
14416                 alc_inithook(codec);
14417 }
14418
14419 #ifdef CONFIG_SND_HDA_POWER_SAVE
14420 static struct hda_amp_list alc861_loopbacks[] = {
14421         { 0x15, HDA_INPUT, 0 },
14422         { 0x15, HDA_INPUT, 1 },
14423         { 0x15, HDA_INPUT, 2 },
14424         { 0x15, HDA_INPUT, 3 },
14425         { } /* end */
14426 };
14427 #endif
14428
14429
14430 /*
14431  * configuration and preset
14432  */
14433 static const char *alc861_models[ALC861_MODEL_LAST] = {
14434         [ALC861_3ST]            = "3stack",
14435         [ALC660_3ST]            = "3stack-660",
14436         [ALC861_3ST_DIG]        = "3stack-dig",
14437         [ALC861_6ST_DIG]        = "6stack-dig",
14438         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14439         [ALC861_TOSHIBA]        = "toshiba",
14440         [ALC861_ASUS]           = "asus",
14441         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14442         [ALC861_AUTO]           = "auto",
14443 };
14444
14445 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14446         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14447         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14448         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14449         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14450         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14451         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14452         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14453         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14454          *        Any other models that need this preset?
14455          */
14456         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14457         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14458         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14459         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14460         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14461         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14462         /* FIXME: the below seems conflict */
14463         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14464         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14465         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14466         {}
14467 };
14468
14469 static struct alc_config_preset alc861_presets[] = {
14470         [ALC861_3ST] = {
14471                 .mixers = { alc861_3ST_mixer },
14472                 .init_verbs = { alc861_threestack_init_verbs },
14473                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14474                 .dac_nids = alc861_dac_nids,
14475                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14476                 .channel_mode = alc861_threestack_modes,
14477                 .need_dac_fix = 1,
14478                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14479                 .adc_nids = alc861_adc_nids,
14480                 .input_mux = &alc861_capture_source,
14481         },
14482         [ALC861_3ST_DIG] = {
14483                 .mixers = { alc861_base_mixer },
14484                 .init_verbs = { alc861_threestack_init_verbs },
14485                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14486                 .dac_nids = alc861_dac_nids,
14487                 .dig_out_nid = ALC861_DIGOUT_NID,
14488                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14489                 .channel_mode = alc861_threestack_modes,
14490                 .need_dac_fix = 1,
14491                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14492                 .adc_nids = alc861_adc_nids,
14493                 .input_mux = &alc861_capture_source,
14494         },
14495         [ALC861_6ST_DIG] = {
14496                 .mixers = { alc861_base_mixer },
14497                 .init_verbs = { alc861_base_init_verbs },
14498                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14499                 .dac_nids = alc861_dac_nids,
14500                 .dig_out_nid = ALC861_DIGOUT_NID,
14501                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14502                 .channel_mode = alc861_8ch_modes,
14503                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14504                 .adc_nids = alc861_adc_nids,
14505                 .input_mux = &alc861_capture_source,
14506         },
14507         [ALC660_3ST] = {
14508                 .mixers = { alc861_3ST_mixer },
14509                 .init_verbs = { alc861_threestack_init_verbs },
14510                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14511                 .dac_nids = alc660_dac_nids,
14512                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14513                 .channel_mode = alc861_threestack_modes,
14514                 .need_dac_fix = 1,
14515                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14516                 .adc_nids = alc861_adc_nids,
14517                 .input_mux = &alc861_capture_source,
14518         },
14519         [ALC861_UNIWILL_M31] = {
14520                 .mixers = { alc861_uniwill_m31_mixer },
14521                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14522                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14523                 .dac_nids = alc861_dac_nids,
14524                 .dig_out_nid = ALC861_DIGOUT_NID,
14525                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14526                 .channel_mode = alc861_uniwill_m31_modes,
14527                 .need_dac_fix = 1,
14528                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14529                 .adc_nids = alc861_adc_nids,
14530                 .input_mux = &alc861_capture_source,
14531         },
14532         [ALC861_TOSHIBA] = {
14533                 .mixers = { alc861_toshiba_mixer },
14534                 .init_verbs = { alc861_base_init_verbs,
14535                                 alc861_toshiba_init_verbs },
14536                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14537                 .dac_nids = alc861_dac_nids,
14538                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14539                 .channel_mode = alc883_3ST_2ch_modes,
14540                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14541                 .adc_nids = alc861_adc_nids,
14542                 .input_mux = &alc861_capture_source,
14543                 .unsol_event = alc861_toshiba_unsol_event,
14544                 .init_hook = alc861_toshiba_automute,
14545         },
14546         [ALC861_ASUS] = {
14547                 .mixers = { alc861_asus_mixer },
14548                 .init_verbs = { alc861_asus_init_verbs },
14549                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14550                 .dac_nids = alc861_dac_nids,
14551                 .dig_out_nid = ALC861_DIGOUT_NID,
14552                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14553                 .channel_mode = alc861_asus_modes,
14554                 .need_dac_fix = 1,
14555                 .hp_nid = 0x06,
14556                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14557                 .adc_nids = alc861_adc_nids,
14558                 .input_mux = &alc861_capture_source,
14559         },
14560         [ALC861_ASUS_LAPTOP] = {
14561                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14562                 .init_verbs = { alc861_asus_init_verbs,
14563                                 alc861_asus_laptop_init_verbs },
14564                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14565                 .dac_nids = alc861_dac_nids,
14566                 .dig_out_nid = ALC861_DIGOUT_NID,
14567                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14568                 .channel_mode = alc883_3ST_2ch_modes,
14569                 .need_dac_fix = 1,
14570                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14571                 .adc_nids = alc861_adc_nids,
14572                 .input_mux = &alc861_capture_source,
14573         },
14574 };
14575
14576
14577 static int patch_alc861(struct hda_codec *codec)
14578 {
14579         struct alc_spec *spec;
14580         int board_config;
14581         int err;
14582
14583         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14584         if (spec == NULL)
14585                 return -ENOMEM;
14586
14587         codec->spec = spec;
14588
14589         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14590                                                   alc861_models,
14591                                                   alc861_cfg_tbl);
14592
14593         if (board_config < 0) {
14594                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14595                        codec->chip_name);
14596                 board_config = ALC861_AUTO;
14597         }
14598
14599         if (board_config == ALC861_AUTO) {
14600                 /* automatic parse from the BIOS config */
14601                 err = alc861_parse_auto_config(codec);
14602                 if (err < 0) {
14603                         alc_free(codec);
14604                         return err;
14605                 } else if (!err) {
14606                         printk(KERN_INFO
14607                                "hda_codec: Cannot set up configuration "
14608                                "from BIOS.  Using base mode...\n");
14609                    board_config = ALC861_3ST_DIG;
14610                 }
14611         }
14612
14613         err = snd_hda_attach_beep_device(codec, 0x23);
14614         if (err < 0) {
14615                 alc_free(codec);
14616                 return err;
14617         }
14618
14619         if (board_config != ALC861_AUTO)
14620                 setup_preset(spec, &alc861_presets[board_config]);
14621
14622         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14623         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14624
14625         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14626         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14627
14628         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14629
14630         spec->vmaster_nid = 0x03;
14631
14632         codec->patch_ops = alc_patch_ops;
14633         if (board_config == ALC861_AUTO)
14634                 spec->init_hook = alc861_auto_init;
14635 #ifdef CONFIG_SND_HDA_POWER_SAVE
14636         if (!spec->loopback.amplist)
14637                 spec->loopback.amplist = alc861_loopbacks;
14638 #endif
14639         codec->proc_widget_hook = print_realtek_coef;
14640
14641         return 0;
14642 }
14643
14644 /*
14645  * ALC861-VD support
14646  *
14647  * Based on ALC882
14648  *
14649  * In addition, an independent DAC
14650  */
14651 #define ALC861VD_DIGOUT_NID     0x06
14652
14653 static hda_nid_t alc861vd_dac_nids[4] = {
14654         /* front, surr, clfe, side surr */
14655         0x02, 0x03, 0x04, 0x05
14656 };
14657
14658 /* dac_nids for ALC660vd are in a different order - according to
14659  * Realtek's driver.
14660  * This should probably result in a different mixer for 6stack models
14661  * of ALC660vd codecs, but for now there is only 3stack mixer
14662  * - and it is the same as in 861vd.
14663  * adc_nids in ALC660vd are (is) the same as in 861vd
14664  */
14665 static hda_nid_t alc660vd_dac_nids[3] = {
14666         /* front, rear, clfe, rear_surr */
14667         0x02, 0x04, 0x03
14668 };
14669
14670 static hda_nid_t alc861vd_adc_nids[1] = {
14671         /* ADC0 */
14672         0x09,
14673 };
14674
14675 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14676
14677 /* input MUX */
14678 /* FIXME: should be a matrix-type input source selection */
14679 static struct hda_input_mux alc861vd_capture_source = {
14680         .num_items = 4,
14681         .items = {
14682                 { "Mic", 0x0 },
14683                 { "Front Mic", 0x1 },
14684                 { "Line", 0x2 },
14685                 { "CD", 0x4 },
14686         },
14687 };
14688
14689 static struct hda_input_mux alc861vd_dallas_capture_source = {
14690         .num_items = 2,
14691         .items = {
14692                 { "Ext Mic", 0x0 },
14693                 { "Int Mic", 0x1 },
14694         },
14695 };
14696
14697 static struct hda_input_mux alc861vd_hp_capture_source = {
14698         .num_items = 2,
14699         .items = {
14700                 { "Front Mic", 0x0 },
14701                 { "ATAPI Mic", 0x1 },
14702         },
14703 };
14704
14705 /*
14706  * 2ch mode
14707  */
14708 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14709         { 2, NULL }
14710 };
14711
14712 /*
14713  * 6ch mode
14714  */
14715 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14716         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14717         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14718         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14719         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14720         { } /* end */
14721 };
14722
14723 /*
14724  * 8ch mode
14725  */
14726 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14727         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14728         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14729         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14730         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14731         { } /* end */
14732 };
14733
14734 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14735         { 6, alc861vd_6stack_ch6_init },
14736         { 8, alc861vd_6stack_ch8_init },
14737 };
14738
14739 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14740         {
14741                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14742                 .name = "Channel Mode",
14743                 .info = alc_ch_mode_info,
14744                 .get = alc_ch_mode_get,
14745                 .put = alc_ch_mode_put,
14746         },
14747         { } /* end */
14748 };
14749
14750 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14751  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14752  */
14753 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14754         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14755         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14756
14757         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14758         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14759
14760         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14761                                 HDA_OUTPUT),
14762         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14763                                 HDA_OUTPUT),
14764         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14765         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14766
14767         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14768         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14769
14770         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14771
14772         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14773         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14774         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14775
14776         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14777         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14778         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14779
14780         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14781         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14782
14783         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14784         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14785
14786         { } /* end */
14787 };
14788
14789 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14790         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14791         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14792
14793         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14794
14795         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14798
14799         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14800         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14801         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14802
14803         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14804         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14805
14806         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14807         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14808
14809         { } /* end */
14810 };
14811
14812 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14813         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14814         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14815         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14816
14817         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14818
14819         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14822
14823         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14824         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14825         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14826
14827         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14828         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14829
14830         { } /* end */
14831 };
14832
14833 /* Pin assignment: Speaker=0x14, HP = 0x15,
14834  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14835  */
14836 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14837         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14838         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14839         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14840         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14841         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14842         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14843         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14844         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14845         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14846         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14847         { } /* end */
14848 };
14849
14850 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14851  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14852  */
14853 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14854         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14855         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14856         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14857         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14858         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14859         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14860         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14861         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14862
14863         { } /* end */
14864 };
14865
14866 /*
14867  * generic initialization of ADC, input mixers and output mixers
14868  */
14869 static struct hda_verb alc861vd_volume_init_verbs[] = {
14870         /*
14871          * Unmute ADC0 and set the default input to mic-in
14872          */
14873         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14874         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14875
14876         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14877          * the analog-loopback mixer widget
14878          */
14879         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14880         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14881         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14882         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14883         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14884         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14885
14886         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14887         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14888         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14889         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14890         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14891
14892         /*
14893          * Set up output mixers (0x02 - 0x05)
14894          */
14895         /* set vol=0 to output mixers */
14896         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14897         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14898         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14899         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14900
14901         /* set up input amps for analog loopback */
14902         /* Amp Indices: DAC = 0, mixer = 1 */
14903         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14904         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14905         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14906         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14907         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14908         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14909         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14910         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14911
14912         { }
14913 };
14914
14915 /*
14916  * 3-stack pin configuration:
14917  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14918  */
14919 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14920         /*
14921          * Set pin mode and muting
14922          */
14923         /* set front pin widgets 0x14 for output */
14924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14925         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14926         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14927
14928         /* Mic (rear) pin: input vref at 80% */
14929         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14930         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14931         /* Front Mic pin: input vref at 80% */
14932         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14933         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14934         /* Line In pin: input */
14935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14936         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14937         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14938         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14940         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14941         /* CD pin widget for input */
14942         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14943
14944         { }
14945 };
14946
14947 /*
14948  * 6-stack pin configuration:
14949  */
14950 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14951         /*
14952          * Set pin mode and muting
14953          */
14954         /* set front pin widgets 0x14 for output */
14955         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14956         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14957         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14958
14959         /* Rear Pin: output 1 (0x0d) */
14960         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14961         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14962         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14963         /* CLFE Pin: output 2 (0x0e) */
14964         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14965         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14966         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
14967         /* Side Pin: output 3 (0x0f) */
14968         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14969         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14970         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
14971
14972         /* Mic (rear) pin: input vref at 80% */
14973         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14974         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14975         /* Front Mic pin: input vref at 80% */
14976         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14977         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14978         /* Line In pin: input */
14979         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14980         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14981         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14982         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14983         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14984         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14985         /* CD pin widget for input */
14986         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14987
14988         { }
14989 };
14990
14991 static struct hda_verb alc861vd_eapd_verbs[] = {
14992         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14993         { }
14994 };
14995
14996 static struct hda_verb alc660vd_eapd_verbs[] = {
14997         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14998         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
14999         { }
15000 };
15001
15002 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15003         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15004         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15005         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15006         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15007         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15008         {}
15009 };
15010
15011 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15012 {
15013         unsigned int present;
15014         unsigned char bits;
15015
15016         present = snd_hda_codec_read(codec, 0x18, 0,
15017                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15018         bits = present ? HDA_AMP_MUTE : 0;
15019         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15020                                  HDA_AMP_MUTE, bits);
15021 }
15022
15023 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15024 {
15025         struct alc_spec *spec = codec->spec;
15026
15027         spec->autocfg.hp_pins[0] = 0x1b;
15028         spec->autocfg.speaker_pins[0] = 0x14;
15029         alc_automute_amp(codec);
15030         alc861vd_lenovo_mic_automute(codec);
15031 }
15032
15033 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15034                                         unsigned int res)
15035 {
15036         switch (res >> 26) {
15037         case ALC880_MIC_EVENT:
15038                 alc861vd_lenovo_mic_automute(codec);
15039                 break;
15040         default:
15041                 alc_automute_amp_unsol_event(codec, res);
15042                 break;
15043         }
15044 }
15045
15046 static struct hda_verb alc861vd_dallas_verbs[] = {
15047         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15048         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15049         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15050         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15051
15052         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15053         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15054         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15055         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15056         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15057         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15058         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15059         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15060
15061         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15062         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15063         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15064         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15065         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15066         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15067         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15068         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15069
15070         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15071         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15072         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15073         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15074         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15075         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15076         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15077         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15078
15079         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15080         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15081         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15082         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15083
15084         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15085         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15086         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15087
15088         { } /* end */
15089 };
15090
15091 /* toggle speaker-output according to the hp-jack state */
15092 static void alc861vd_dallas_init_hook(struct hda_codec *codec)
15093 {
15094         struct alc_spec *spec = codec->spec;
15095
15096         spec->autocfg.hp_pins[0] = 0x15;
15097         spec->autocfg.speaker_pins[0] = 0x14;
15098         alc_automute_amp(codec);
15099 }
15100
15101 #ifdef CONFIG_SND_HDA_POWER_SAVE
15102 #define alc861vd_loopbacks      alc880_loopbacks
15103 #endif
15104
15105 /* pcm configuration: identical with ALC880 */
15106 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15107 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15108 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15109 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15110
15111 /*
15112  * configuration and preset
15113  */
15114 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15115         [ALC660VD_3ST]          = "3stack-660",
15116         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15117         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15118         [ALC861VD_3ST]          = "3stack",
15119         [ALC861VD_3ST_DIG]      = "3stack-digout",
15120         [ALC861VD_6ST_DIG]      = "6stack-digout",
15121         [ALC861VD_LENOVO]       = "lenovo",
15122         [ALC861VD_DALLAS]       = "dallas",
15123         [ALC861VD_HP]           = "hp",
15124         [ALC861VD_AUTO]         = "auto",
15125 };
15126
15127 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15128         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15129         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15130         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15131         SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),
15132         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15133         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15134         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15135         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15136         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15137         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15138         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15139         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15140         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15141         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15142         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15143         {}
15144 };
15145
15146 static struct alc_config_preset alc861vd_presets[] = {
15147         [ALC660VD_3ST] = {
15148                 .mixers = { alc861vd_3st_mixer },
15149                 .init_verbs = { alc861vd_volume_init_verbs,
15150                                  alc861vd_3stack_init_verbs },
15151                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15152                 .dac_nids = alc660vd_dac_nids,
15153                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15154                 .channel_mode = alc861vd_3stack_2ch_modes,
15155                 .input_mux = &alc861vd_capture_source,
15156         },
15157         [ALC660VD_3ST_DIG] = {
15158                 .mixers = { alc861vd_3st_mixer },
15159                 .init_verbs = { alc861vd_volume_init_verbs,
15160                                  alc861vd_3stack_init_verbs },
15161                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15162                 .dac_nids = alc660vd_dac_nids,
15163                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15164                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15165                 .channel_mode = alc861vd_3stack_2ch_modes,
15166                 .input_mux = &alc861vd_capture_source,
15167         },
15168         [ALC861VD_3ST] = {
15169                 .mixers = { alc861vd_3st_mixer },
15170                 .init_verbs = { alc861vd_volume_init_verbs,
15171                                  alc861vd_3stack_init_verbs },
15172                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15173                 .dac_nids = alc861vd_dac_nids,
15174                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15175                 .channel_mode = alc861vd_3stack_2ch_modes,
15176                 .input_mux = &alc861vd_capture_source,
15177         },
15178         [ALC861VD_3ST_DIG] = {
15179                 .mixers = { alc861vd_3st_mixer },
15180                 .init_verbs = { alc861vd_volume_init_verbs,
15181                                  alc861vd_3stack_init_verbs },
15182                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15183                 .dac_nids = alc861vd_dac_nids,
15184                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15185                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15186                 .channel_mode = alc861vd_3stack_2ch_modes,
15187                 .input_mux = &alc861vd_capture_source,
15188         },
15189         [ALC861VD_6ST_DIG] = {
15190                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15191                 .init_verbs = { alc861vd_volume_init_verbs,
15192                                 alc861vd_6stack_init_verbs },
15193                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15194                 .dac_nids = alc861vd_dac_nids,
15195                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15196                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15197                 .channel_mode = alc861vd_6stack_modes,
15198                 .input_mux = &alc861vd_capture_source,
15199         },
15200         [ALC861VD_LENOVO] = {
15201                 .mixers = { alc861vd_lenovo_mixer },
15202                 .init_verbs = { alc861vd_volume_init_verbs,
15203                                 alc861vd_3stack_init_verbs,
15204                                 alc861vd_eapd_verbs,
15205                                 alc861vd_lenovo_unsol_verbs },
15206                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15207                 .dac_nids = alc660vd_dac_nids,
15208                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15209                 .channel_mode = alc861vd_3stack_2ch_modes,
15210                 .input_mux = &alc861vd_capture_source,
15211                 .unsol_event = alc861vd_lenovo_unsol_event,
15212                 .init_hook = alc861vd_lenovo_init_hook,
15213         },
15214         [ALC861VD_DALLAS] = {
15215                 .mixers = { alc861vd_dallas_mixer },
15216                 .init_verbs = { alc861vd_dallas_verbs },
15217                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15218                 .dac_nids = alc861vd_dac_nids,
15219                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15220                 .channel_mode = alc861vd_3stack_2ch_modes,
15221                 .input_mux = &alc861vd_dallas_capture_source,
15222                 .unsol_event = alc_automute_amp_unsol_event,
15223                 .init_hook = alc861vd_dallas_init_hook,
15224         },
15225         [ALC861VD_HP] = {
15226                 .mixers = { alc861vd_hp_mixer },
15227                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15228                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15229                 .dac_nids = alc861vd_dac_nids,
15230                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15231                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15232                 .channel_mode = alc861vd_3stack_2ch_modes,
15233                 .input_mux = &alc861vd_hp_capture_source,
15234                 .unsol_event = alc_automute_amp_unsol_event,
15235                 .init_hook = alc861vd_dallas_init_hook,
15236         },
15237         [ALC660VD_ASUS_V1S] = {
15238                 .mixers = { alc861vd_lenovo_mixer },
15239                 .init_verbs = { alc861vd_volume_init_verbs,
15240                                 alc861vd_3stack_init_verbs,
15241                                 alc861vd_eapd_verbs,
15242                                 alc861vd_lenovo_unsol_verbs },
15243                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15244                 .dac_nids = alc660vd_dac_nids,
15245                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15246                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15247                 .channel_mode = alc861vd_3stack_2ch_modes,
15248                 .input_mux = &alc861vd_capture_source,
15249                 .unsol_event = alc861vd_lenovo_unsol_event,
15250                 .init_hook = alc861vd_lenovo_init_hook,
15251         },
15252 };
15253
15254 /*
15255  * BIOS auto configuration
15256  */
15257 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15258                                 hda_nid_t nid, int pin_type, int dac_idx)
15259 {
15260         alc_set_pin_output(codec, nid, pin_type);
15261 }
15262
15263 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15264 {
15265         struct alc_spec *spec = codec->spec;
15266         int i;
15267
15268         for (i = 0; i <= HDA_SIDE; i++) {
15269                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15270                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15271                 if (nid)
15272                         alc861vd_auto_set_output_and_unmute(codec, nid,
15273                                                             pin_type, i);
15274         }
15275 }
15276
15277
15278 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15279 {
15280         struct alc_spec *spec = codec->spec;
15281         hda_nid_t pin;
15282
15283         pin = spec->autocfg.hp_pins[0];
15284         if (pin) /* connect to front and use dac 0 */
15285                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15286         pin = spec->autocfg.speaker_pins[0];
15287         if (pin)
15288                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15289 }
15290
15291 #define alc861vd_is_input_pin(nid)      alc880_is_input_pin(nid)
15292 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15293
15294 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15295 {
15296         struct alc_spec *spec = codec->spec;
15297         int i;
15298
15299         for (i = 0; i < AUTO_PIN_LAST; i++) {
15300                 hda_nid_t nid = spec->autocfg.input_pins[i];
15301                 if (alc861vd_is_input_pin(nid)) {
15302                         alc_set_input_pin(codec, nid, i);
15303                         if (nid != ALC861VD_PIN_CD_NID &&
15304                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15305                                 snd_hda_codec_write(codec, nid, 0,
15306                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15307                                                 AMP_OUT_MUTE);
15308                 }
15309         }
15310 }
15311
15312 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15313
15314 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15315 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15316
15317 /* add playback controls from the parsed DAC table */
15318 /* Based on ALC880 version. But ALC861VD has separate,
15319  * different NIDs for mute/unmute switch and volume control */
15320 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15321                                              const struct auto_pin_cfg *cfg)
15322 {
15323         char name[32];
15324         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15325         hda_nid_t nid_v, nid_s;
15326         int i, err;
15327
15328         for (i = 0; i < cfg->line_outs; i++) {
15329                 if (!spec->multiout.dac_nids[i])
15330                         continue;
15331                 nid_v = alc861vd_idx_to_mixer_vol(
15332                                 alc880_dac_to_idx(
15333                                         spec->multiout.dac_nids[i]));
15334                 nid_s = alc861vd_idx_to_mixer_switch(
15335                                 alc880_dac_to_idx(
15336                                         spec->multiout.dac_nids[i]));
15337
15338                 if (i == 2) {
15339                         /* Center/LFE */
15340                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15341                                           "Center Playback Volume",
15342                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15343                                                               HDA_OUTPUT));
15344                         if (err < 0)
15345                                 return err;
15346                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15347                                           "LFE Playback Volume",
15348                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15349                                                               HDA_OUTPUT));
15350                         if (err < 0)
15351                                 return err;
15352                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15353                                           "Center Playback Switch",
15354                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15355                                                               HDA_INPUT));
15356                         if (err < 0)
15357                                 return err;
15358                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15359                                           "LFE Playback Switch",
15360                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15361                                                               HDA_INPUT));
15362                         if (err < 0)
15363                                 return err;
15364                 } else {
15365                         sprintf(name, "%s Playback Volume", chname[i]);
15366                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15367                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15368                                                               HDA_OUTPUT));
15369                         if (err < 0)
15370                                 return err;
15371                         sprintf(name, "%s Playback Switch", chname[i]);
15372                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15373                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15374                                                               HDA_INPUT));
15375                         if (err < 0)
15376                                 return err;
15377                 }
15378         }
15379         return 0;
15380 }
15381
15382 /* add playback controls for speaker and HP outputs */
15383 /* Based on ALC880 version. But ALC861VD has separate,
15384  * different NIDs for mute/unmute switch and volume control */
15385 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15386                                         hda_nid_t pin, const char *pfx)
15387 {
15388         hda_nid_t nid_v, nid_s;
15389         int err;
15390         char name[32];
15391
15392         if (!pin)
15393                 return 0;
15394
15395         if (alc880_is_fixed_pin(pin)) {
15396                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15397                 /* specify the DAC as the extra output */
15398                 if (!spec->multiout.hp_nid)
15399                         spec->multiout.hp_nid = nid_v;
15400                 else
15401                         spec->multiout.extra_out_nid[0] = nid_v;
15402                 /* control HP volume/switch on the output mixer amp */
15403                 nid_v = alc861vd_idx_to_mixer_vol(
15404                                 alc880_fixed_pin_idx(pin));
15405                 nid_s = alc861vd_idx_to_mixer_switch(
15406                                 alc880_fixed_pin_idx(pin));
15407
15408                 sprintf(name, "%s Playback Volume", pfx);
15409                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15410                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15411                 if (err < 0)
15412                         return err;
15413                 sprintf(name, "%s Playback Switch", pfx);
15414                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15415                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15416                 if (err < 0)
15417                         return err;
15418         } else if (alc880_is_multi_pin(pin)) {
15419                 /* set manual connection */
15420                 /* we have only a switch on HP-out PIN */
15421                 sprintf(name, "%s Playback Switch", pfx);
15422                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15423                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15424                 if (err < 0)
15425                         return err;
15426         }
15427         return 0;
15428 }
15429
15430 /* parse the BIOS configuration and set up the alc_spec
15431  * return 1 if successful, 0 if the proper config is not found,
15432  * or a negative error code
15433  * Based on ALC880 version - had to change it to override
15434  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15435 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15436 {
15437         struct alc_spec *spec = codec->spec;
15438         int err;
15439         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15440
15441         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15442                                            alc861vd_ignore);
15443         if (err < 0)
15444                 return err;
15445         if (!spec->autocfg.line_outs)
15446                 return 0; /* can't find valid BIOS pin config */
15447
15448         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15449         if (err < 0)
15450                 return err;
15451         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15452         if (err < 0)
15453                 return err;
15454         err = alc861vd_auto_create_extra_out(spec,
15455                                              spec->autocfg.speaker_pins[0],
15456                                              "Speaker");
15457         if (err < 0)
15458                 return err;
15459         err = alc861vd_auto_create_extra_out(spec,
15460                                              spec->autocfg.hp_pins[0],
15461                                              "Headphone");
15462         if (err < 0)
15463                 return err;
15464         err = alc880_auto_create_analog_input_ctls(spec, &spec->autocfg);
15465         if (err < 0)
15466                 return err;
15467
15468         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15469
15470         if (spec->autocfg.dig_outs)
15471                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15472
15473         if (spec->kctls.list)
15474                 add_mixer(spec, spec->kctls.list);
15475
15476         add_verb(spec, alc861vd_volume_init_verbs);
15477
15478         spec->num_mux_defs = 1;
15479         spec->input_mux = &spec->private_imux[0];
15480
15481         err = alc_auto_add_mic_boost(codec);
15482         if (err < 0)
15483                 return err;
15484
15485         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15486
15487         return 1;
15488 }
15489
15490 /* additional initialization for auto-configuration model */
15491 static void alc861vd_auto_init(struct hda_codec *codec)
15492 {
15493         struct alc_spec *spec = codec->spec;
15494         alc861vd_auto_init_multi_out(codec);
15495         alc861vd_auto_init_hp_out(codec);
15496         alc861vd_auto_init_analog_input(codec);
15497         alc861vd_auto_init_input_src(codec);
15498         if (spec->unsol_event)
15499                 alc_inithook(codec);
15500 }
15501
15502 static int patch_alc861vd(struct hda_codec *codec)
15503 {
15504         struct alc_spec *spec;
15505         int err, board_config;
15506
15507         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15508         if (spec == NULL)
15509                 return -ENOMEM;
15510
15511         codec->spec = spec;
15512
15513         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15514                                                   alc861vd_models,
15515                                                   alc861vd_cfg_tbl);
15516
15517         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15518                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15519                        codec->chip_name);
15520                 board_config = ALC861VD_AUTO;
15521         }
15522
15523         if (board_config == ALC861VD_AUTO) {
15524                 /* automatic parse from the BIOS config */
15525                 err = alc861vd_parse_auto_config(codec);
15526                 if (err < 0) {
15527                         alc_free(codec);
15528                         return err;
15529                 } else if (!err) {
15530                         printk(KERN_INFO
15531                                "hda_codec: Cannot set up configuration "
15532                                "from BIOS.  Using base mode...\n");
15533                         board_config = ALC861VD_3ST;
15534                 }
15535         }
15536
15537         err = snd_hda_attach_beep_device(codec, 0x23);
15538         if (err < 0) {
15539                 alc_free(codec);
15540                 return err;
15541         }
15542
15543         if (board_config != ALC861VD_AUTO)
15544                 setup_preset(spec, &alc861vd_presets[board_config]);
15545
15546         if (codec->vendor_id == 0x10ec0660) {
15547                 /* always turn on EAPD */
15548                 add_verb(spec, alc660vd_eapd_verbs);
15549         }
15550
15551         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15552         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15553
15554         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15555         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15556
15557         spec->adc_nids = alc861vd_adc_nids;
15558         spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15559         spec->capsrc_nids = alc861vd_capsrc_nids;
15560
15561         set_capture_mixer(spec);
15562         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15563
15564         spec->vmaster_nid = 0x02;
15565
15566         codec->patch_ops = alc_patch_ops;
15567
15568         if (board_config == ALC861VD_AUTO)
15569                 spec->init_hook = alc861vd_auto_init;
15570 #ifdef CONFIG_SND_HDA_POWER_SAVE
15571         if (!spec->loopback.amplist)
15572                 spec->loopback.amplist = alc861vd_loopbacks;
15573 #endif
15574         codec->proc_widget_hook = print_realtek_coef;
15575
15576         return 0;
15577 }
15578
15579 /*
15580  * ALC662 support
15581  *
15582  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15583  * configuration.  Each pin widget can choose any input DACs and a mixer.
15584  * Each ADC is connected from a mixer of all inputs.  This makes possible
15585  * 6-channel independent captures.
15586  *
15587  * In addition, an independent DAC for the multi-playback (not used in this
15588  * driver yet).
15589  */
15590 #define ALC662_DIGOUT_NID       0x06
15591 #define ALC662_DIGIN_NID        0x0a
15592
15593 static hda_nid_t alc662_dac_nids[4] = {
15594         /* front, rear, clfe, rear_surr */
15595         0x02, 0x03, 0x04
15596 };
15597
15598 static hda_nid_t alc272_dac_nids[2] = {
15599         0x02, 0x03
15600 };
15601
15602 static hda_nid_t alc662_adc_nids[1] = {
15603         /* ADC1-2 */
15604         0x09,
15605 };
15606
15607 static hda_nid_t alc272_adc_nids[1] = {
15608         /* ADC1-2 */
15609         0x08,
15610 };
15611
15612 static hda_nid_t alc662_capsrc_nids[1] = { 0x22 };
15613 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15614
15615
15616 /* input MUX */
15617 /* FIXME: should be a matrix-type input source selection */
15618 static struct hda_input_mux alc662_capture_source = {
15619         .num_items = 4,
15620         .items = {
15621                 { "Mic", 0x0 },
15622                 { "Front Mic", 0x1 },
15623                 { "Line", 0x2 },
15624                 { "CD", 0x4 },
15625         },
15626 };
15627
15628 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15629         .num_items = 2,
15630         .items = {
15631                 { "Mic", 0x1 },
15632                 { "Line", 0x2 },
15633         },
15634 };
15635
15636 static struct hda_input_mux alc662_eeepc_capture_source = {
15637         .num_items = 2,
15638         .items = {
15639                 { "i-Mic", 0x1 },
15640                 { "e-Mic", 0x0 },
15641         },
15642 };
15643
15644 static struct hda_input_mux alc663_capture_source = {
15645         .num_items = 3,
15646         .items = {
15647                 { "Mic", 0x0 },
15648                 { "Front Mic", 0x1 },
15649                 { "Line", 0x2 },
15650         },
15651 };
15652
15653 static struct hda_input_mux alc663_m51va_capture_source = {
15654         .num_items = 2,
15655         .items = {
15656                 { "Ext-Mic", 0x0 },
15657                 { "D-Mic", 0x9 },
15658         },
15659 };
15660
15661 #if 1 /* set to 0 for testing other input sources below */
15662 static struct hda_input_mux alc272_nc10_capture_source = {
15663         .num_items = 2,
15664         .items = {
15665                 { "Autoselect Mic", 0x0 },
15666                 { "Internal Mic", 0x1 },
15667         },
15668 };
15669 #else
15670 static struct hda_input_mux alc272_nc10_capture_source = {
15671         .num_items = 16,
15672         .items = {
15673                 { "Autoselect Mic", 0x0 },
15674                 { "Internal Mic", 0x1 },
15675                 { "In-0x02", 0x2 },
15676                 { "In-0x03", 0x3 },
15677                 { "In-0x04", 0x4 },
15678                 { "In-0x05", 0x5 },
15679                 { "In-0x06", 0x6 },
15680                 { "In-0x07", 0x7 },
15681                 { "In-0x08", 0x8 },
15682                 { "In-0x09", 0x9 },
15683                 { "In-0x0a", 0x0a },
15684                 { "In-0x0b", 0x0b },
15685                 { "In-0x0c", 0x0c },
15686                 { "In-0x0d", 0x0d },
15687                 { "In-0x0e", 0x0e },
15688                 { "In-0x0f", 0x0f },
15689         },
15690 };
15691 #endif
15692
15693 /*
15694  * 2ch mode
15695  */
15696 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15697         { 2, NULL }
15698 };
15699
15700 /*
15701  * 2ch mode
15702  */
15703 static struct hda_verb alc662_3ST_ch2_init[] = {
15704         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15705         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15706         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15707         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15708         { } /* end */
15709 };
15710
15711 /*
15712  * 6ch mode
15713  */
15714 static struct hda_verb alc662_3ST_ch6_init[] = {
15715         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15716         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15717         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15718         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15719         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15720         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15721         { } /* end */
15722 };
15723
15724 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15725         { 2, alc662_3ST_ch2_init },
15726         { 6, alc662_3ST_ch6_init },
15727 };
15728
15729 /*
15730  * 2ch mode
15731  */
15732 static struct hda_verb alc662_sixstack_ch6_init[] = {
15733         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15734         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15735         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15736         { } /* end */
15737 };
15738
15739 /*
15740  * 6ch mode
15741  */
15742 static struct hda_verb alc662_sixstack_ch8_init[] = {
15743         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15744         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15745         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15746         { } /* end */
15747 };
15748
15749 static struct hda_channel_mode alc662_5stack_modes[2] = {
15750         { 2, alc662_sixstack_ch6_init },
15751         { 6, alc662_sixstack_ch8_init },
15752 };
15753
15754 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15755  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15756  */
15757
15758 static struct snd_kcontrol_new alc662_base_mixer[] = {
15759         /* output mixer control */
15760         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15761         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15762         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15763         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15764         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15765         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15766         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15767         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15768         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15769
15770         /*Input mixer control */
15771         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15772         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15773         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15774         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15775         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15776         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15777         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15778         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15779         { } /* end */
15780 };
15781
15782 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15783         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15784         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15785         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15786         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15787         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15788         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15789         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15790         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15791         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15792         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15793         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15794         { } /* end */
15795 };
15796
15797 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15798         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15799         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15800         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15801         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15802         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15803         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15804         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15805         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15806         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15807         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15808         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15809         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15810         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15811         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15813         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15814         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15815         { } /* end */
15816 };
15817
15818 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15819         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15820         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15821         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15822         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15823         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15824         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15825         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15826         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15827         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15828         { } /* end */
15829 };
15830
15831 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15832         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15833         ALC262_HIPPO_MASTER_SWITCH,
15834
15835         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15836         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15837         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15838
15839         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15840         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15841         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15842         { } /* end */
15843 };
15844
15845 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15846         ALC262_HIPPO_MASTER_SWITCH,
15847         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15848         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15849         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15850         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15851         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15852         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15853         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15854         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15855         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15856         { } /* end */
15857 };
15858
15859 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15860         .ops = &snd_hda_bind_vol,
15861         .values = {
15862                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15863                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15864                 0
15865         },
15866 };
15867
15868 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15869         .ops = &snd_hda_bind_sw,
15870         .values = {
15871                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15872                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15873                 0
15874         },
15875 };
15876
15877 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15878         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15879         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15880         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15881         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15882         { } /* end */
15883 };
15884
15885 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15886         .ops = &snd_hda_bind_sw,
15887         .values = {
15888                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15889                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15890                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15891                 0
15892         },
15893 };
15894
15895 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15896         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15897         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15898         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15899         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15900         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15901         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15902
15903         { } /* end */
15904 };
15905
15906 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15907         .ops = &snd_hda_bind_sw,
15908         .values = {
15909                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15910                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15911                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15912                 0
15913         },
15914 };
15915
15916 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15917         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15918         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15919         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15920         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15921         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15922         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15923         { } /* end */
15924 };
15925
15926 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
15927         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15928         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15929         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15932         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15933         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15934         { } /* end */
15935 };
15936
15937 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
15938         .ops = &snd_hda_bind_vol,
15939         .values = {
15940                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15941                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
15942                 0
15943         },
15944 };
15945
15946 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
15947         .ops = &snd_hda_bind_sw,
15948         .values = {
15949                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15950                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
15951                 0
15952         },
15953 };
15954
15955 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
15956         HDA_BIND_VOL("Master Playback Volume",
15957                                 &alc663_asus_two_bind_master_vol),
15958         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15959         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15960         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15961         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15962         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15963         { } /* end */
15964 };
15965
15966 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
15967         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15968         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
15969         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15970         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15971         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15972         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15973         { } /* end */
15974 };
15975
15976 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
15977         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15978         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15979         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15980         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15981         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15982
15983         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15984         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15985         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15986         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15987         { } /* end */
15988 };
15989
15990 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
15991         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15992         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15993         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
15994
15995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15996         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15997         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15998         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15999         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16000         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16001         { } /* end */
16002 };
16003
16004 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16005         {
16006                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16007                 .name = "Channel Mode",
16008                 .info = alc_ch_mode_info,
16009                 .get = alc_ch_mode_get,
16010                 .put = alc_ch_mode_put,
16011         },
16012         { } /* end */
16013 };
16014
16015 static struct hda_verb alc662_init_verbs[] = {
16016         /* ADC: mute amp left and right */
16017         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16018         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16019         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16020
16021         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16022         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16023         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16024         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16025         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16026
16027         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16028         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16029         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16030         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16031         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16032         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16033
16034         /* Front Pin: output 0 (0x0c) */
16035         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16036         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16037
16038         /* Rear Pin: output 1 (0x0d) */
16039         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16040         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16041
16042         /* CLFE Pin: output 2 (0x0e) */
16043         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16044         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16045
16046         /* Mic (rear) pin: input vref at 80% */
16047         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16048         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16049         /* Front Mic pin: input vref at 80% */
16050         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16051         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16052         /* Line In pin: input */
16053         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16054         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16055         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16056         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16057         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16058         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16059         /* CD pin widget for input */
16060         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16061
16062         /* FIXME: use matrix-type input source selection */
16063         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16064         /* Input mixer */
16065         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16066         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16067
16068         /* always trun on EAPD */
16069         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16070         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16071
16072         { }
16073 };
16074
16075 static struct hda_verb alc662_sue_init_verbs[] = {
16076         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16077         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16078         {}
16079 };
16080
16081 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16082         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16083         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16084         {}
16085 };
16086
16087 /* Set Unsolicited Event*/
16088 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16089         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16090         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16091         {}
16092 };
16093
16094 /*
16095  * generic initialization of ADC, input mixers and output mixers
16096  */
16097 static struct hda_verb alc662_auto_init_verbs[] = {
16098         /*
16099          * Unmute ADC and set the default input to mic-in
16100          */
16101         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16102         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16103
16104         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16105          * mixer widget
16106          * Note: PASD motherboards uses the Line In 2 as the input for front
16107          * panel mic (mic 2)
16108          */
16109         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16110         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16111         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16115
16116         /*
16117          * Set up output mixers (0x0c - 0x0f)
16118          */
16119         /* set vol=0 to output mixers */
16120         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16121         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16122         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16123
16124         /* set up input amps for analog loopback */
16125         /* Amp Indices: DAC = 0, mixer = 1 */
16126         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16128         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16129         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16130         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16131         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16132
16133
16134         /* FIXME: use matrix-type input source selection */
16135         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16136         /* Input mixer */
16137         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16138         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16139         { }
16140 };
16141
16142 /* additional verbs for ALC663 */
16143 static struct hda_verb alc663_auto_init_verbs[] = {
16144         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16145         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16146         { }
16147 };
16148
16149 static struct hda_verb alc663_m51va_init_verbs[] = {
16150         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16151         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16152         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16153         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16154         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16155         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16156         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16157         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16158         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16159         {}
16160 };
16161
16162 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16163         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16164         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16165         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16166         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16167         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16168         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16169         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16170         {}
16171 };
16172
16173 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16174         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16175         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16176         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16177         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16178         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16179         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16180         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16181         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16182         {}
16183 };
16184
16185 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16186         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16187         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16188         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16189         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16190         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16191         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16192         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16193         {}
16194 };
16195
16196 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16197         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16198         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16199         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16200         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16201         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16202         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16203         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16204         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16205         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16206         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16207         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16208         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16209         {}
16210 };
16211
16212 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16213         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16214         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16215         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16216         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16217         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16218         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16219         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16220         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16221         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16222         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16223         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16224         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16225         {}
16226 };
16227
16228 static struct hda_verb alc663_g71v_init_verbs[] = {
16229         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16230         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16231         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16232
16233         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16234         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16235         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16236
16237         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16238         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16239         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16240         {}
16241 };
16242
16243 static struct hda_verb alc663_g50v_init_verbs[] = {
16244         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16245         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16246         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16247
16248         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16249         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16250         {}
16251 };
16252
16253 static struct hda_verb alc662_ecs_init_verbs[] = {
16254         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16255         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16256         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16257         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16258         {}
16259 };
16260
16261 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16262         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16263         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16264         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16265         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16266         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16267         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16268         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16269         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16270         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16271         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16272         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16273         {}
16274 };
16275
16276 static struct hda_verb alc272_dell_init_verbs[] = {
16277         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16278         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16279         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16280         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16281         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16282         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16283         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16284         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16285         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16286         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16287         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16288         {}
16289 };
16290
16291 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16292         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16293         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16294         { } /* end */
16295 };
16296
16297 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16298         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16299         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16300         { } /* end */
16301 };
16302
16303 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16304 {
16305         unsigned int present;
16306         unsigned char bits;
16307
16308         present = snd_hda_codec_read(codec, 0x14, 0,
16309                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16310         bits = present ? HDA_AMP_MUTE : 0;
16311         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16312                                  HDA_AMP_MUTE, bits);
16313 }
16314
16315 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16316 {
16317         unsigned int present;
16318         unsigned char bits;
16319
16320         present = snd_hda_codec_read(codec, 0x1b, 0,
16321                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16322         bits = present ? HDA_AMP_MUTE : 0;
16323         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16324                                  HDA_AMP_MUTE, bits);
16325         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16326                                  HDA_AMP_MUTE, bits);
16327 }
16328
16329 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16330                                            unsigned int res)
16331 {
16332         if ((res >> 26) == ALC880_HP_EVENT)
16333                 alc662_lenovo_101e_all_automute(codec);
16334         if ((res >> 26) == ALC880_FRONT_EVENT)
16335                 alc662_lenovo_101e_ispeaker_automute(codec);
16336 }
16337
16338 static void alc662_eeepc_mic_automute(struct hda_codec *codec)
16339 {
16340         unsigned int present;
16341
16342         present = snd_hda_codec_read(codec, 0x18, 0,
16343                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16344         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16345                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16346         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16347                             0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16348         snd_hda_codec_write(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16349                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
16350         snd_hda_codec_write(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16351                             0x7000 | (0x01 << 8) | (present ? 0x80 : 0));
16352 }
16353
16354 /* unsolicited event for HP jack sensing */
16355 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16356                                      unsigned int res)
16357 {
16358         if ((res >> 26) == ALC880_MIC_EVENT)
16359                 alc662_eeepc_mic_automute(codec);
16360         else
16361                 alc262_hippo_unsol_event(codec, res);
16362 }
16363
16364 static void alc662_eeepc_inithook(struct hda_codec *codec)
16365 {
16366         alc262_hippo1_init_hook(codec);
16367         alc662_eeepc_mic_automute(codec);
16368 }
16369
16370 static void alc662_eeepc_ep20_inithook(struct hda_codec *codec)
16371 {
16372         struct alc_spec *spec = codec->spec;
16373
16374         spec->autocfg.hp_pins[0] = 0x14;
16375         spec->autocfg.speaker_pins[0] = 0x1b;
16376         alc262_hippo_master_update(codec);
16377 }
16378
16379 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16380 {
16381         unsigned int present;
16382         unsigned char bits;
16383
16384         present = snd_hda_codec_read(codec, 0x21, 0,
16385                         AC_VERB_GET_PIN_SENSE, 0)
16386                         & AC_PINSENSE_PRESENCE;
16387         bits = present ? HDA_AMP_MUTE : 0;
16388         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16389                                 AMP_IN_MUTE(0), bits);
16390         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16391                                 AMP_IN_MUTE(0), bits);
16392 }
16393
16394 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16395 {
16396         unsigned int present;
16397         unsigned char bits;
16398
16399         present = snd_hda_codec_read(codec, 0x21, 0,
16400                         AC_VERB_GET_PIN_SENSE, 0)
16401                         & AC_PINSENSE_PRESENCE;
16402         bits = present ? HDA_AMP_MUTE : 0;
16403         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16404                                 AMP_IN_MUTE(0), bits);
16405         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16406                                 AMP_IN_MUTE(0), bits);
16407         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16408                                 AMP_IN_MUTE(0), bits);
16409         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16410                                 AMP_IN_MUTE(0), bits);
16411 }
16412
16413 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16414 {
16415         unsigned int present;
16416         unsigned char bits;
16417
16418         present = snd_hda_codec_read(codec, 0x15, 0,
16419                         AC_VERB_GET_PIN_SENSE, 0)
16420                         & AC_PINSENSE_PRESENCE;
16421         bits = present ? HDA_AMP_MUTE : 0;
16422         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16423                                 AMP_IN_MUTE(0), bits);
16424         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16425                                 AMP_IN_MUTE(0), bits);
16426         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16427                                 AMP_IN_MUTE(0), bits);
16428         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16429                                 AMP_IN_MUTE(0), bits);
16430 }
16431
16432 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16433 {
16434         unsigned int present;
16435         unsigned char bits;
16436
16437         present = snd_hda_codec_read(codec, 0x1b, 0,
16438                         AC_VERB_GET_PIN_SENSE, 0)
16439                         & AC_PINSENSE_PRESENCE;
16440         bits = present ? 0 : PIN_OUT;
16441         snd_hda_codec_write(codec, 0x14, 0,
16442                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16443 }
16444
16445 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16446 {
16447         unsigned int present1, present2;
16448
16449         present1 = snd_hda_codec_read(codec, 0x21, 0,
16450                         AC_VERB_GET_PIN_SENSE, 0)
16451                         & AC_PINSENSE_PRESENCE;
16452         present2 = snd_hda_codec_read(codec, 0x15, 0,
16453                         AC_VERB_GET_PIN_SENSE, 0)
16454                         & AC_PINSENSE_PRESENCE;
16455
16456         if (present1 || present2) {
16457                 snd_hda_codec_write_cache(codec, 0x14, 0,
16458                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16459         } else {
16460                 snd_hda_codec_write_cache(codec, 0x14, 0,
16461                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16462         }
16463 }
16464
16465 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16466 {
16467         unsigned int present1, present2;
16468
16469         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16470                                 AC_VERB_GET_PIN_SENSE, 0)
16471                                 & AC_PINSENSE_PRESENCE;
16472         present2 = snd_hda_codec_read(codec, 0x15, 0,
16473                                 AC_VERB_GET_PIN_SENSE, 0)
16474                                 & AC_PINSENSE_PRESENCE;
16475
16476         if (present1 || present2) {
16477                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16478                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16479                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16480                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16481         } else {
16482                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16483                                 AMP_IN_MUTE(0), 0);
16484                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16485                                 AMP_IN_MUTE(0), 0);
16486         }
16487 }
16488
16489 static void alc663_m51va_mic_automute(struct hda_codec *codec)
16490 {
16491         unsigned int present;
16492
16493         present = snd_hda_codec_read(codec, 0x18, 0,
16494                         AC_VERB_GET_PIN_SENSE, 0)
16495                         & AC_PINSENSE_PRESENCE;
16496         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16497                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16498         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16499                         0x7000 | (0x00 << 8) | (present ? 0 : 0x80));
16500         snd_hda_codec_write_cache(codec, 0x22, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16501                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16502         snd_hda_codec_write_cache(codec, 0x23, 0, AC_VERB_SET_AMP_GAIN_MUTE,
16503                         0x7000 | (0x09 << 8) | (present ? 0x80 : 0));
16504 }
16505
16506 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16507                                            unsigned int res)
16508 {
16509         switch (res >> 26) {
16510         case ALC880_HP_EVENT:
16511                 alc663_m51va_speaker_automute(codec);
16512                 break;
16513         case ALC880_MIC_EVENT:
16514                 alc663_m51va_mic_automute(codec);
16515                 break;
16516         }
16517 }
16518
16519 static void alc663_m51va_inithook(struct hda_codec *codec)
16520 {
16521         alc663_m51va_speaker_automute(codec);
16522         alc663_m51va_mic_automute(codec);
16523 }
16524
16525 /* ***************** Mode1 ******************************/
16526 static void alc663_mode1_unsol_event(struct hda_codec *codec,
16527                                            unsigned int res)
16528 {
16529         switch (res >> 26) {
16530         case ALC880_HP_EVENT:
16531                 alc663_m51va_speaker_automute(codec);
16532                 break;
16533         case ALC880_MIC_EVENT:
16534                 alc662_eeepc_mic_automute(codec);
16535                 break;
16536         }
16537 }
16538
16539 static void alc663_mode1_inithook(struct hda_codec *codec)
16540 {
16541         alc663_m51va_speaker_automute(codec);
16542         alc662_eeepc_mic_automute(codec);
16543 }
16544 /* ***************** Mode2 ******************************/
16545 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16546                                            unsigned int res)
16547 {
16548         switch (res >> 26) {
16549         case ALC880_HP_EVENT:
16550                 alc662_f5z_speaker_automute(codec);
16551                 break;
16552         case ALC880_MIC_EVENT:
16553                 alc662_eeepc_mic_automute(codec);
16554                 break;
16555         }
16556 }
16557
16558 static void alc662_mode2_inithook(struct hda_codec *codec)
16559 {
16560         alc662_f5z_speaker_automute(codec);
16561         alc662_eeepc_mic_automute(codec);
16562 }
16563 /* ***************** Mode3 ******************************/
16564 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16565                                            unsigned int res)
16566 {
16567         switch (res >> 26) {
16568         case ALC880_HP_EVENT:
16569                 alc663_two_hp_m1_speaker_automute(codec);
16570                 break;
16571         case ALC880_MIC_EVENT:
16572                 alc662_eeepc_mic_automute(codec);
16573                 break;
16574         }
16575 }
16576
16577 static void alc663_mode3_inithook(struct hda_codec *codec)
16578 {
16579         alc663_two_hp_m1_speaker_automute(codec);
16580         alc662_eeepc_mic_automute(codec);
16581 }
16582 /* ***************** Mode4 ******************************/
16583 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16584                                            unsigned int res)
16585 {
16586         switch (res >> 26) {
16587         case ALC880_HP_EVENT:
16588                 alc663_21jd_two_speaker_automute(codec);
16589                 break;
16590         case ALC880_MIC_EVENT:
16591                 alc662_eeepc_mic_automute(codec);
16592                 break;
16593         }
16594 }
16595
16596 static void alc663_mode4_inithook(struct hda_codec *codec)
16597 {
16598         alc663_21jd_two_speaker_automute(codec);
16599         alc662_eeepc_mic_automute(codec);
16600 }
16601 /* ***************** Mode5 ******************************/
16602 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16603                                            unsigned int res)
16604 {
16605         switch (res >> 26) {
16606         case ALC880_HP_EVENT:
16607                 alc663_15jd_two_speaker_automute(codec);
16608                 break;
16609         case ALC880_MIC_EVENT:
16610                 alc662_eeepc_mic_automute(codec);
16611                 break;
16612         }
16613 }
16614
16615 static void alc663_mode5_inithook(struct hda_codec *codec)
16616 {
16617         alc663_15jd_two_speaker_automute(codec);
16618         alc662_eeepc_mic_automute(codec);
16619 }
16620 /* ***************** Mode6 ******************************/
16621 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16622                                            unsigned int res)
16623 {
16624         switch (res >> 26) {
16625         case ALC880_HP_EVENT:
16626                 alc663_two_hp_m2_speaker_automute(codec);
16627                 break;
16628         case ALC880_MIC_EVENT:
16629                 alc662_eeepc_mic_automute(codec);
16630                 break;
16631         }
16632 }
16633
16634 static void alc663_mode6_inithook(struct hda_codec *codec)
16635 {
16636         alc663_two_hp_m2_speaker_automute(codec);
16637         alc662_eeepc_mic_automute(codec);
16638 }
16639
16640 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16641 {
16642         unsigned int present;
16643         unsigned char bits;
16644
16645         present = snd_hda_codec_read(codec, 0x21, 0,
16646                                      AC_VERB_GET_PIN_SENSE, 0)
16647                 & AC_PINSENSE_PRESENCE;
16648         bits = present ? HDA_AMP_MUTE : 0;
16649         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16650                                  HDA_AMP_MUTE, bits);
16651         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16652                                  HDA_AMP_MUTE, bits);
16653 }
16654
16655 static void alc663_g71v_front_automute(struct hda_codec *codec)
16656 {
16657         unsigned int present;
16658         unsigned char bits;
16659
16660         present = snd_hda_codec_read(codec, 0x15, 0,
16661                                      AC_VERB_GET_PIN_SENSE, 0)
16662                 & AC_PINSENSE_PRESENCE;
16663         bits = present ? HDA_AMP_MUTE : 0;
16664         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16665                                  HDA_AMP_MUTE, bits);
16666 }
16667
16668 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16669                                            unsigned int res)
16670 {
16671         switch (res >> 26) {
16672         case ALC880_HP_EVENT:
16673                 alc663_g71v_hp_automute(codec);
16674                 break;
16675         case ALC880_FRONT_EVENT:
16676                 alc663_g71v_front_automute(codec);
16677                 break;
16678         case ALC880_MIC_EVENT:
16679                 alc662_eeepc_mic_automute(codec);
16680                 break;
16681         }
16682 }
16683
16684 static void alc663_g71v_inithook(struct hda_codec *codec)
16685 {
16686         alc663_g71v_front_automute(codec);
16687         alc663_g71v_hp_automute(codec);
16688         alc662_eeepc_mic_automute(codec);
16689 }
16690
16691 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16692                                            unsigned int res)
16693 {
16694         switch (res >> 26) {
16695         case ALC880_HP_EVENT:
16696                 alc663_m51va_speaker_automute(codec);
16697                 break;
16698         case ALC880_MIC_EVENT:
16699                 alc662_eeepc_mic_automute(codec);
16700                 break;
16701         }
16702 }
16703
16704 static void alc663_g50v_inithook(struct hda_codec *codec)
16705 {
16706         alc663_m51va_speaker_automute(codec);
16707         alc662_eeepc_mic_automute(codec);
16708 }
16709
16710 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16711         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16712         ALC262_HIPPO_MASTER_SWITCH,
16713
16714         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16715         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16716         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16717
16718         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16719         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16720         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16721         { } /* end */
16722 };
16723
16724 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16725         /* Master Playback automatically created from Speaker and Headphone */
16726         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16727         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16728         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16729         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16730
16731         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16732         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16733         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16734
16735         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16736         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16737         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16738         { } /* end */
16739 };
16740
16741 #ifdef CONFIG_SND_HDA_POWER_SAVE
16742 #define alc662_loopbacks        alc880_loopbacks
16743 #endif
16744
16745
16746 /* pcm configuration: identical with ALC880 */
16747 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16748 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16749 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16750 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16751
16752 /*
16753  * configuration and preset
16754  */
16755 static const char *alc662_models[ALC662_MODEL_LAST] = {
16756         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16757         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16758         [ALC662_3ST_6ch]        = "3stack-6ch",
16759         [ALC662_5ST_DIG]        = "6stack-dig",
16760         [ALC662_LENOVO_101E]    = "lenovo-101e",
16761         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16762         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16763         [ALC662_ECS] = "ecs",
16764         [ALC663_ASUS_M51VA] = "m51va",
16765         [ALC663_ASUS_G71V] = "g71v",
16766         [ALC663_ASUS_H13] = "h13",
16767         [ALC663_ASUS_G50V] = "g50v",
16768         [ALC663_ASUS_MODE1] = "asus-mode1",
16769         [ALC662_ASUS_MODE2] = "asus-mode2",
16770         [ALC663_ASUS_MODE3] = "asus-mode3",
16771         [ALC663_ASUS_MODE4] = "asus-mode4",
16772         [ALC663_ASUS_MODE5] = "asus-mode5",
16773         [ALC663_ASUS_MODE6] = "asus-mode6",
16774         [ALC272_DELL]           = "dell",
16775         [ALC272_DELL_ZM1]       = "dell-zm1",
16776         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16777         [ALC662_AUTO]           = "auto",
16778 };
16779
16780 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16781         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16782         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16783         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16784         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16785         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16786         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16787         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16788         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16789         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16790         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16791         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16792         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16793         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16794         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16795         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16796         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16797         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16798         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16799         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16800         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16801         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16802         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16803         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16804         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16805         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16806         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16807         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16808         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16809         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16810         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16811         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16812         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16813         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16814         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16815         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16816         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16817         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16818         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16819         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16820         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16821         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16822         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16823         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16824         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16825         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16826         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16827         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16828         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16829         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16830         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16831         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16832         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16833                       ALC662_3ST_6ch_DIG),
16834         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16835         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16836                       ALC662_3ST_6ch_DIG),
16837         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16838         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16839         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16840         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16841                                         ALC662_3ST_6ch_DIG),
16842         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16843                            ALC663_ASUS_H13),
16844         {}
16845 };
16846
16847 static struct alc_config_preset alc662_presets[] = {
16848         [ALC662_3ST_2ch_DIG] = {
16849                 .mixers = { alc662_3ST_2ch_mixer },
16850                 .init_verbs = { alc662_init_verbs },
16851                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16852                 .dac_nids = alc662_dac_nids,
16853                 .dig_out_nid = ALC662_DIGOUT_NID,
16854                 .dig_in_nid = ALC662_DIGIN_NID,
16855                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16856                 .channel_mode = alc662_3ST_2ch_modes,
16857                 .input_mux = &alc662_capture_source,
16858         },
16859         [ALC662_3ST_6ch_DIG] = {
16860                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16861                 .init_verbs = { alc662_init_verbs },
16862                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16863                 .dac_nids = alc662_dac_nids,
16864                 .dig_out_nid = ALC662_DIGOUT_NID,
16865                 .dig_in_nid = ALC662_DIGIN_NID,
16866                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16867                 .channel_mode = alc662_3ST_6ch_modes,
16868                 .need_dac_fix = 1,
16869                 .input_mux = &alc662_capture_source,
16870         },
16871         [ALC662_3ST_6ch] = {
16872                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16873                 .init_verbs = { alc662_init_verbs },
16874                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16875                 .dac_nids = alc662_dac_nids,
16876                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16877                 .channel_mode = alc662_3ST_6ch_modes,
16878                 .need_dac_fix = 1,
16879                 .input_mux = &alc662_capture_source,
16880         },
16881         [ALC662_5ST_DIG] = {
16882                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16883                 .init_verbs = { alc662_init_verbs },
16884                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16885                 .dac_nids = alc662_dac_nids,
16886                 .dig_out_nid = ALC662_DIGOUT_NID,
16887                 .dig_in_nid = ALC662_DIGIN_NID,
16888                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16889                 .channel_mode = alc662_5stack_modes,
16890                 .input_mux = &alc662_capture_source,
16891         },
16892         [ALC662_LENOVO_101E] = {
16893                 .mixers = { alc662_lenovo_101e_mixer },
16894                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16895                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16896                 .dac_nids = alc662_dac_nids,
16897                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16898                 .channel_mode = alc662_3ST_2ch_modes,
16899                 .input_mux = &alc662_lenovo_101e_capture_source,
16900                 .unsol_event = alc662_lenovo_101e_unsol_event,
16901                 .init_hook = alc662_lenovo_101e_all_automute,
16902         },
16903         [ALC662_ASUS_EEEPC_P701] = {
16904                 .mixers = { alc662_eeepc_p701_mixer },
16905                 .init_verbs = { alc662_init_verbs,
16906                                 alc662_eeepc_sue_init_verbs },
16907                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16908                 .dac_nids = alc662_dac_nids,
16909                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16910                 .channel_mode = alc662_3ST_2ch_modes,
16911                 .input_mux = &alc662_eeepc_capture_source,
16912                 .unsol_event = alc662_eeepc_unsol_event,
16913                 .init_hook = alc662_eeepc_inithook,
16914         },
16915         [ALC662_ASUS_EEEPC_EP20] = {
16916                 .mixers = { alc662_eeepc_ep20_mixer,
16917                             alc662_chmode_mixer },
16918                 .init_verbs = { alc662_init_verbs,
16919                                 alc662_eeepc_ep20_sue_init_verbs },
16920                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16921                 .dac_nids = alc662_dac_nids,
16922                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16923                 .channel_mode = alc662_3ST_6ch_modes,
16924                 .input_mux = &alc662_lenovo_101e_capture_source,
16925                 .unsol_event = alc662_eeepc_unsol_event,
16926                 .init_hook = alc662_eeepc_ep20_inithook,
16927         },
16928         [ALC662_ECS] = {
16929                 .mixers = { alc662_ecs_mixer },
16930                 .init_verbs = { alc662_init_verbs,
16931                                 alc662_ecs_init_verbs },
16932                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16933                 .dac_nids = alc662_dac_nids,
16934                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16935                 .channel_mode = alc662_3ST_2ch_modes,
16936                 .input_mux = &alc662_eeepc_capture_source,
16937                 .unsol_event = alc662_eeepc_unsol_event,
16938                 .init_hook = alc662_eeepc_inithook,
16939         },
16940         [ALC663_ASUS_M51VA] = {
16941                 .mixers = { alc663_m51va_mixer },
16942                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16943                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16944                 .dac_nids = alc662_dac_nids,
16945                 .dig_out_nid = ALC662_DIGOUT_NID,
16946                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16947                 .channel_mode = alc662_3ST_2ch_modes,
16948                 .input_mux = &alc663_m51va_capture_source,
16949                 .unsol_event = alc663_m51va_unsol_event,
16950                 .init_hook = alc663_m51va_inithook,
16951         },
16952         [ALC663_ASUS_G71V] = {
16953                 .mixers = { alc663_g71v_mixer },
16954                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
16955                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16956                 .dac_nids = alc662_dac_nids,
16957                 .dig_out_nid = ALC662_DIGOUT_NID,
16958                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16959                 .channel_mode = alc662_3ST_2ch_modes,
16960                 .input_mux = &alc662_eeepc_capture_source,
16961                 .unsol_event = alc663_g71v_unsol_event,
16962                 .init_hook = alc663_g71v_inithook,
16963         },
16964         [ALC663_ASUS_H13] = {
16965                 .mixers = { alc663_m51va_mixer },
16966                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
16967                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16968                 .dac_nids = alc662_dac_nids,
16969                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16970                 .channel_mode = alc662_3ST_2ch_modes,
16971                 .input_mux = &alc663_m51va_capture_source,
16972                 .unsol_event = alc663_m51va_unsol_event,
16973                 .init_hook = alc663_m51va_inithook,
16974         },
16975         [ALC663_ASUS_G50V] = {
16976                 .mixers = { alc663_g50v_mixer },
16977                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
16978                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16979                 .dac_nids = alc662_dac_nids,
16980                 .dig_out_nid = ALC662_DIGOUT_NID,
16981                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16982                 .channel_mode = alc662_3ST_6ch_modes,
16983                 .input_mux = &alc663_capture_source,
16984                 .unsol_event = alc663_g50v_unsol_event,
16985                 .init_hook = alc663_g50v_inithook,
16986         },
16987         [ALC663_ASUS_MODE1] = {
16988                 .mixers = { alc663_m51va_mixer },
16989                 .cap_mixer = alc662_auto_capture_mixer,
16990                 .init_verbs = { alc662_init_verbs,
16991                                 alc663_21jd_amic_init_verbs },
16992                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16993                 .hp_nid = 0x03,
16994                 .dac_nids = alc662_dac_nids,
16995                 .dig_out_nid = ALC662_DIGOUT_NID,
16996                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16997                 .channel_mode = alc662_3ST_2ch_modes,
16998                 .input_mux = &alc662_eeepc_capture_source,
16999                 .unsol_event = alc663_mode1_unsol_event,
17000                 .init_hook = alc663_mode1_inithook,
17001         },
17002         [ALC662_ASUS_MODE2] = {
17003                 .mixers = { alc662_1bjd_mixer },
17004                 .cap_mixer = alc662_auto_capture_mixer,
17005                 .init_verbs = { alc662_init_verbs,
17006                                 alc662_1bjd_amic_init_verbs },
17007                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17008                 .dac_nids = alc662_dac_nids,
17009                 .dig_out_nid = ALC662_DIGOUT_NID,
17010                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17011                 .channel_mode = alc662_3ST_2ch_modes,
17012                 .input_mux = &alc662_eeepc_capture_source,
17013                 .unsol_event = alc662_mode2_unsol_event,
17014                 .init_hook = alc662_mode2_inithook,
17015         },
17016         [ALC663_ASUS_MODE3] = {
17017                 .mixers = { alc663_two_hp_m1_mixer },
17018                 .cap_mixer = alc662_auto_capture_mixer,
17019                 .init_verbs = { alc662_init_verbs,
17020                                 alc663_two_hp_amic_m1_init_verbs },
17021                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17022                 .hp_nid = 0x03,
17023                 .dac_nids = alc662_dac_nids,
17024                 .dig_out_nid = ALC662_DIGOUT_NID,
17025                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17026                 .channel_mode = alc662_3ST_2ch_modes,
17027                 .input_mux = &alc662_eeepc_capture_source,
17028                 .unsol_event = alc663_mode3_unsol_event,
17029                 .init_hook = alc663_mode3_inithook,
17030         },
17031         [ALC663_ASUS_MODE4] = {
17032                 .mixers = { alc663_asus_21jd_clfe_mixer },
17033                 .cap_mixer = alc662_auto_capture_mixer,
17034                 .init_verbs = { alc662_init_verbs,
17035                                 alc663_21jd_amic_init_verbs},
17036                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17037                 .hp_nid = 0x03,
17038                 .dac_nids = alc662_dac_nids,
17039                 .dig_out_nid = ALC662_DIGOUT_NID,
17040                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17041                 .channel_mode = alc662_3ST_2ch_modes,
17042                 .input_mux = &alc662_eeepc_capture_source,
17043                 .unsol_event = alc663_mode4_unsol_event,
17044                 .init_hook = alc663_mode4_inithook,
17045         },
17046         [ALC663_ASUS_MODE5] = {
17047                 .mixers = { alc663_asus_15jd_clfe_mixer },
17048                 .cap_mixer = alc662_auto_capture_mixer,
17049                 .init_verbs = { alc662_init_verbs,
17050                                 alc663_15jd_amic_init_verbs },
17051                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17052                 .hp_nid = 0x03,
17053                 .dac_nids = alc662_dac_nids,
17054                 .dig_out_nid = ALC662_DIGOUT_NID,
17055                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17056                 .channel_mode = alc662_3ST_2ch_modes,
17057                 .input_mux = &alc662_eeepc_capture_source,
17058                 .unsol_event = alc663_mode5_unsol_event,
17059                 .init_hook = alc663_mode5_inithook,
17060         },
17061         [ALC663_ASUS_MODE6] = {
17062                 .mixers = { alc663_two_hp_m2_mixer },
17063                 .cap_mixer = alc662_auto_capture_mixer,
17064                 .init_verbs = { alc662_init_verbs,
17065                                 alc663_two_hp_amic_m2_init_verbs },
17066                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17067                 .hp_nid = 0x03,
17068                 .dac_nids = alc662_dac_nids,
17069                 .dig_out_nid = ALC662_DIGOUT_NID,
17070                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17071                 .channel_mode = alc662_3ST_2ch_modes,
17072                 .input_mux = &alc662_eeepc_capture_source,
17073                 .unsol_event = alc663_mode6_unsol_event,
17074                 .init_hook = alc663_mode6_inithook,
17075         },
17076         [ALC272_DELL] = {
17077                 .mixers = { alc663_m51va_mixer },
17078                 .cap_mixer = alc272_auto_capture_mixer,
17079                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17080                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17081                 .dac_nids = alc662_dac_nids,
17082                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17083                 .adc_nids = alc272_adc_nids,
17084                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17085                 .capsrc_nids = alc272_capsrc_nids,
17086                 .channel_mode = alc662_3ST_2ch_modes,
17087                 .input_mux = &alc663_m51va_capture_source,
17088                 .unsol_event = alc663_m51va_unsol_event,
17089                 .init_hook = alc663_m51va_inithook,
17090         },
17091         [ALC272_DELL_ZM1] = {
17092                 .mixers = { alc663_m51va_mixer },
17093                 .cap_mixer = alc662_auto_capture_mixer,
17094                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17095                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17096                 .dac_nids = alc662_dac_nids,
17097                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17098                 .adc_nids = alc662_adc_nids,
17099                 .num_adc_nids = ARRAY_SIZE(alc662_adc_nids),
17100                 .capsrc_nids = alc662_capsrc_nids,
17101                 .channel_mode = alc662_3ST_2ch_modes,
17102                 .input_mux = &alc663_m51va_capture_source,
17103                 .unsol_event = alc663_m51va_unsol_event,
17104                 .init_hook = alc663_m51va_inithook,
17105         },
17106         [ALC272_SAMSUNG_NC10] = {
17107                 .mixers = { alc272_nc10_mixer },
17108                 .init_verbs = { alc662_init_verbs,
17109                                 alc663_21jd_amic_init_verbs },
17110                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17111                 .dac_nids = alc272_dac_nids,
17112                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17113                 .channel_mode = alc662_3ST_2ch_modes,
17114                 .input_mux = &alc272_nc10_capture_source,
17115                 .unsol_event = alc663_mode4_unsol_event,
17116                 .init_hook = alc663_mode4_inithook,
17117         },
17118 };
17119
17120
17121 /*
17122  * BIOS auto configuration
17123  */
17124
17125 /* add playback controls from the parsed DAC table */
17126 static int alc662_auto_create_multi_out_ctls(struct alc_spec *spec,
17127                                              const struct auto_pin_cfg *cfg)
17128 {
17129         char name[32];
17130         static const char *chname[4] = {
17131                 "Front", "Surround", NULL /*CLFE*/, "Side"
17132         };
17133         hda_nid_t nid;
17134         int i, err;
17135
17136         for (i = 0; i < cfg->line_outs; i++) {
17137                 if (!spec->multiout.dac_nids[i])
17138                         continue;
17139                 nid = alc880_idx_to_dac(i);
17140                 if (i == 2) {
17141                         /* Center/LFE */
17142                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
17143                                           "Center Playback Volume",
17144                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
17145                                                               HDA_OUTPUT));
17146                         if (err < 0)
17147                                 return err;
17148                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
17149                                           "LFE Playback Volume",
17150                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
17151                                                               HDA_OUTPUT));
17152                         if (err < 0)
17153                                 return err;
17154                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
17155                                           "Center Playback Switch",
17156                                           HDA_COMPOSE_AMP_VAL(0x0e, 1, 0,
17157                                                               HDA_INPUT));
17158                         if (err < 0)
17159                                 return err;
17160                         err = add_control(spec, ALC_CTL_WIDGET_MUTE,
17161                                           "LFE Playback Switch",
17162                                           HDA_COMPOSE_AMP_VAL(0x0e, 2, 0,
17163                                                               HDA_INPUT));
17164                         if (err < 0)
17165                                 return err;
17166                 } else {
17167                         sprintf(name, "%s Playback Volume", chname[i]);
17168                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
17169                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
17170                                                               HDA_OUTPUT));
17171                         if (err < 0)
17172                                 return err;
17173                         sprintf(name, "%s Playback Switch", chname[i]);
17174                         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17175                                 HDA_COMPOSE_AMP_VAL(alc880_idx_to_mixer(i),
17176                                                     3, 0, HDA_INPUT));
17177                         if (err < 0)
17178                                 return err;
17179                 }
17180         }
17181         return 0;
17182 }
17183
17184 /* add playback controls for speaker and HP outputs */
17185 static int alc662_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
17186                                         const char *pfx)
17187 {
17188         hda_nid_t nid;
17189         int err;
17190         char name[32];
17191
17192         if (!pin)
17193                 return 0;
17194
17195         if (pin == 0x17) {
17196                 /* ALC663 has a mono output pin on 0x17 */
17197                 sprintf(name, "%s Playback Switch", pfx);
17198                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17199                                   HDA_COMPOSE_AMP_VAL(pin, 2, 0, HDA_OUTPUT));
17200                 return err;
17201         }
17202
17203         if (alc880_is_fixed_pin(pin)) {
17204                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17205                 /* printk(KERN_DEBUG "DAC nid=%x\n",nid); */
17206                 /* specify the DAC as the extra output */
17207                 if (!spec->multiout.hp_nid)
17208                         spec->multiout.hp_nid = nid;
17209                 else
17210                         spec->multiout.extra_out_nid[0] = nid;
17211                 /* control HP volume/switch on the output mixer amp */
17212                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
17213                 sprintf(name, "%s Playback Volume", pfx);
17214                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
17215                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
17216                 if (err < 0)
17217                         return err;
17218                 sprintf(name, "%s Playback Switch", pfx);
17219                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
17220                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
17221                 if (err < 0)
17222                         return err;
17223         } else if (alc880_is_multi_pin(pin)) {
17224                 /* set manual connection */
17225                 /* we have only a switch on HP-out PIN */
17226                 sprintf(name, "%s Playback Switch", pfx);
17227                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17228                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17229                 if (err < 0)
17230                         return err;
17231         }
17232         return 0;
17233 }
17234
17235 static int alc662_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
17236 {
17237         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
17238         return (pincap & AC_PINCAP_IN) != 0;
17239 }
17240
17241 /* create playback/capture controls for input pins */
17242 static int alc662_auto_create_analog_input_ctls(struct hda_codec *codec,
17243                                                 const struct auto_pin_cfg *cfg)
17244 {
17245         struct alc_spec *spec = codec->spec;
17246         struct hda_input_mux *imux = &spec->private_imux[0];
17247         int i, err, idx;
17248
17249         for (i = 0; i < AUTO_PIN_LAST; i++) {
17250                 if (alc662_is_input_pin(codec, cfg->input_pins[i])) {
17251                         idx = get_connection_index(codec, 0x0b,
17252                                                    cfg->input_pins[i]);
17253                         if (idx >= 0) {
17254                                 err = new_analog_input(spec, cfg->input_pins[i],
17255                                                        auto_pin_cfg_labels[i],
17256                                                        idx, 0x0b);
17257                                 if (err < 0)
17258                                         return err;
17259                         }
17260                         idx = get_connection_index(codec, 0x22,
17261                                                    cfg->input_pins[i]);
17262                         if (idx >= 0) {
17263                                 imux->items[imux->num_items].label =
17264                                         auto_pin_cfg_labels[i];
17265                                 imux->items[imux->num_items].index = idx;
17266                                 imux->num_items++;
17267                         }
17268                 }
17269         }
17270         return 0;
17271 }
17272
17273 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17274                                               hda_nid_t nid, int pin_type,
17275                                               int dac_idx)
17276 {
17277         alc_set_pin_output(codec, nid, pin_type);
17278         /* need the manual connection? */
17279         if (alc880_is_multi_pin(nid)) {
17280                 struct alc_spec *spec = codec->spec;
17281                 int idx = alc880_multi_pin_idx(nid);
17282                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
17283                                     AC_VERB_SET_CONNECT_SEL,
17284                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
17285         }
17286 }
17287
17288 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17289 {
17290         struct alc_spec *spec = codec->spec;
17291         int i;
17292
17293         for (i = 0; i <= HDA_SIDE; i++) {
17294                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17295                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
17296                 if (nid)
17297                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17298                                                           i);
17299         }
17300 }
17301
17302 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17303 {
17304         struct alc_spec *spec = codec->spec;
17305         hda_nid_t pin;
17306
17307         pin = spec->autocfg.hp_pins[0];
17308         if (pin) /* connect to front */
17309                 /* use dac 0 */
17310                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
17311         pin = spec->autocfg.speaker_pins[0];
17312         if (pin)
17313                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
17314 }
17315
17316 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17317
17318 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17319 {
17320         struct alc_spec *spec = codec->spec;
17321         int i;
17322
17323         for (i = 0; i < AUTO_PIN_LAST; i++) {
17324                 hda_nid_t nid = spec->autocfg.input_pins[i];
17325                 if (alc662_is_input_pin(codec, nid)) {
17326                         alc_set_input_pin(codec, nid, i);
17327                         if (nid != ALC662_PIN_CD_NID &&
17328                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17329                                 snd_hda_codec_write(codec, nid, 0,
17330                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17331                                                     AMP_OUT_MUTE);
17332                 }
17333         }
17334 }
17335
17336 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17337
17338 static int alc662_parse_auto_config(struct hda_codec *codec)
17339 {
17340         struct alc_spec *spec = codec->spec;
17341         int err;
17342         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17343
17344         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17345                                            alc662_ignore);
17346         if (err < 0)
17347                 return err;
17348         if (!spec->autocfg.line_outs)
17349                 return 0; /* can't find valid BIOS pin config */
17350
17351         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
17352         if (err < 0)
17353                 return err;
17354         err = alc662_auto_create_multi_out_ctls(spec, &spec->autocfg);
17355         if (err < 0)
17356                 return err;
17357         err = alc662_auto_create_extra_out(spec,
17358                                            spec->autocfg.speaker_pins[0],
17359                                            "Speaker");
17360         if (err < 0)
17361                 return err;
17362         err = alc662_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
17363                                            "Headphone");
17364         if (err < 0)
17365                 return err;
17366         err = alc662_auto_create_analog_input_ctls(codec, &spec->autocfg);
17367         if (err < 0)
17368                 return err;
17369
17370         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17371
17372         if (spec->autocfg.dig_outs)
17373                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17374
17375         if (spec->kctls.list)
17376                 add_mixer(spec, spec->kctls.list);
17377
17378         spec->num_mux_defs = 1;
17379         spec->input_mux = &spec->private_imux[0];
17380
17381         add_verb(spec, alc662_auto_init_verbs);
17382         if (codec->vendor_id == 0x10ec0663)
17383                 add_verb(spec, alc663_auto_init_verbs);
17384
17385         err = alc_auto_add_mic_boost(codec);
17386         if (err < 0)
17387                 return err;
17388
17389         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17390
17391         return 1;
17392 }
17393
17394 /* additional initialization for auto-configuration model */
17395 static void alc662_auto_init(struct hda_codec *codec)
17396 {
17397         struct alc_spec *spec = codec->spec;
17398         alc662_auto_init_multi_out(codec);
17399         alc662_auto_init_hp_out(codec);
17400         alc662_auto_init_analog_input(codec);
17401         alc662_auto_init_input_src(codec);
17402         if (spec->unsol_event)
17403                 alc_inithook(codec);
17404 }
17405
17406 static int patch_alc662(struct hda_codec *codec)
17407 {
17408         struct alc_spec *spec;
17409         int err, board_config;
17410
17411         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17412         if (!spec)
17413                 return -ENOMEM;
17414
17415         codec->spec = spec;
17416
17417         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17418
17419         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17420                                                   alc662_models,
17421                                                   alc662_cfg_tbl);
17422         if (board_config < 0) {
17423                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17424                        codec->chip_name);
17425                 board_config = ALC662_AUTO;
17426         }
17427
17428         if (board_config == ALC662_AUTO) {
17429                 /* automatic parse from the BIOS config */
17430                 err = alc662_parse_auto_config(codec);
17431                 if (err < 0) {
17432                         alc_free(codec);
17433                         return err;
17434                 } else if (!err) {
17435                         printk(KERN_INFO
17436                                "hda_codec: Cannot set up configuration "
17437                                "from BIOS.  Using base mode...\n");
17438                         board_config = ALC662_3ST_2ch_DIG;
17439                 }
17440         }
17441
17442         err = snd_hda_attach_beep_device(codec, 0x1);
17443         if (err < 0) {
17444                 alc_free(codec);
17445                 return err;
17446         }
17447
17448         if (board_config != ALC662_AUTO)
17449                 setup_preset(spec, &alc662_presets[board_config]);
17450
17451         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17452         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17453
17454         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17455         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17456
17457         spec->adc_nids = alc662_adc_nids;
17458         spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17459         spec->capsrc_nids = alc662_capsrc_nids;
17460
17461         if (!spec->cap_mixer)
17462                 set_capture_mixer(spec);
17463         if (codec->vendor_id == 0x10ec0662)
17464                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17465         else
17466                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17467
17468         spec->vmaster_nid = 0x02;
17469
17470         codec->patch_ops = alc_patch_ops;
17471         if (board_config == ALC662_AUTO)
17472                 spec->init_hook = alc662_auto_init;
17473 #ifdef CONFIG_SND_HDA_POWER_SAVE
17474         if (!spec->loopback.amplist)
17475                 spec->loopback.amplist = alc662_loopbacks;
17476 #endif
17477         codec->proc_widget_hook = print_realtek_coef;
17478
17479         return 0;
17480 }
17481
17482 /*
17483  * patch entries
17484  */
17485 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17486         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17487         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17488         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17489         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17490         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17491         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17492         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17493           .patch = patch_alc861 },
17494         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17495         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17496         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17497         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17498           .patch = patch_alc882 },
17499         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17500           .patch = patch_alc662 },
17501         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17502         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17503         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17504         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17505         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17506           .patch = patch_alc882 },
17507         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17508           .patch = patch_alc882 },
17509         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17510         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17511         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17512           .patch = patch_alc882 },
17513         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
17514         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17515         {} /* terminator */
17516 };
17517
17518 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17519
17520 MODULE_LICENSE("GPL");
17521 MODULE_DESCRIPTION("Realtek HD-audio codec");
17522
17523 static struct hda_codec_preset_list realtek_list = {
17524         .preset = snd_hda_preset_realtek,
17525         .owner = THIS_MODULE,
17526 };
17527
17528 static int __init patch_realtek_init(void)
17529 {
17530         return snd_hda_add_codec_preset(&realtek_list);
17531 }
17532
17533 static void __exit patch_realtek_exit(void)
17534 {
17535         snd_hda_delete_codec_preset(&realtek_list);
17536 }
17537
17538 module_init(patch_realtek_init)
17539 module_exit(patch_realtek_exit)