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_AMIC,
 135         ALC269_DMIC,
 136         ALC269VB_AMIC,
 137         ALC269VB_DMIC,
 138         ALC269_FUJITSU,
 139         ALC269_LIFEBOOK,
 140         ALC271_ACER,
 141         ALC269_AUTO,
 142         ALC269_MODEL_LAST /* last tag */
 143 };
 144
 145 /* ALC861 models */
 146 enum {
 147         ALC861_3ST,
 148         ALC660_3ST,
 149         ALC861_3ST_DIG,
 150         ALC861_6ST_DIG,
 151         ALC861_UNIWILL_M31,
 152         ALC861_TOSHIBA,
 153         ALC861_ASUS,
 154         ALC861_ASUS_LAPTOP,
 155         ALC861_AUTO,
 156         ALC861_MODEL_LAST,
 157 };
 158
 159 /* ALC861-VD models */
 160 enum {
 161         ALC660VD_3ST,
 162         ALC660VD_3ST_DIG,
 163         ALC660VD_ASUS_V1S,
 164         ALC861VD_3ST,
 165         ALC861VD_3ST_DIG,
 166         ALC861VD_6ST_DIG,
 167         ALC861VD_LENOVO,
 168         ALC861VD_DALLAS,
 169         ALC861VD_HP,
 170         ALC861VD_AUTO,
 171         ALC861VD_MODEL_LAST,
 172 };
 173
 174 /* ALC662 models */
 175 enum {
 176         ALC662_3ST_2ch_DIG,
 177         ALC662_3ST_6ch_DIG,
 178         ALC662_3ST_6ch,
 179         ALC662_5ST_DIG,
 180         ALC662_LENOVO_101E,
 181         ALC662_ASUS_EEEPC_P701,
 182         ALC662_ASUS_EEEPC_EP20,
 183         ALC663_ASUS_M51VA,
 184         ALC663_ASUS_G71V,
 185         ALC663_ASUS_H13,
 186         ALC663_ASUS_G50V,
 187         ALC662_ECS,
 188         ALC663_ASUS_MODE1,
 189         ALC662_ASUS_MODE2,
 190         ALC663_ASUS_MODE3,
 191         ALC663_ASUS_MODE4,
 192         ALC663_ASUS_MODE5,
 193         ALC663_ASUS_MODE6,
 194         ALC663_ASUS_MODE7,
 195         ALC663_ASUS_MODE8,
 196         ALC272_DELL,
 197         ALC272_DELL_ZM1,
 198         ALC272_SAMSUNG_NC10,
 199         ALC662_AUTO,
 200         ALC662_MODEL_LAST,
 201 };
 202
 203 /* ALC882 models */
 204 enum {
 205         ALC882_3ST_DIG,
 206         ALC882_6ST_DIG,
 207         ALC882_ARIMA,
 208         ALC882_W2JC,
 209         ALC882_TARGA,
 210         ALC882_ASUS_A7J,
 211         ALC882_ASUS_A7M,
 212         ALC885_MACPRO,
 213         ALC885_MBA21,
 214         ALC885_MBP3,
 215         ALC885_MB5,
 216         ALC885_MACMINI3,
 217         ALC885_IMAC24,
 218         ALC885_IMAC91,
 219         ALC883_3ST_2ch_DIG,
 220         ALC883_3ST_6ch_DIG,
 221         ALC883_3ST_6ch,
 222         ALC883_6ST_DIG,
 223         ALC883_TARGA_DIG,
 224         ALC883_TARGA_2ch_DIG,
 225         ALC883_TARGA_8ch_DIG,
 226         ALC883_ACER,
 227         ALC883_ACER_ASPIRE,
 228         ALC888_ACER_ASPIRE_4930G,
 229         ALC888_ACER_ASPIRE_6530G,
 230         ALC888_ACER_ASPIRE_8930G,
 231         ALC888_ACER_ASPIRE_7730G,
 232         ALC883_MEDION,
 233         ALC883_MEDION_MD2,
 234         ALC883_MEDION_WIM2160,
 235         ALC883_LAPTOP_EAPD,
 236         ALC883_LENOVO_101E_2ch,
 237         ALC883_LENOVO_NB0763,
 238         ALC888_LENOVO_MS7195_DIG,
 239         ALC888_LENOVO_SKY,
 240         ALC883_HAIER_W66,
 241         ALC888_3ST_HP,
 242         ALC888_6ST_DELL,
 243         ALC883_MITAC,
 244         ALC883_CLEVO_M540R,
 245         ALC883_CLEVO_M720,
 246         ALC883_FUJITSU_PI2515,
 247         ALC888_FUJITSU_XA3530,
 248         ALC883_3ST_6ch_INTEL,
 249         ALC889A_INTEL,
 250         ALC889_INTEL,
 251         ALC888_ASUS_M90V,
 252         ALC888_ASUS_EEE1601,
 253         ALC889A_MB31,
 254         ALC1200_ASUS_P5Q,
 255         ALC883_SONY_VAIO_TT,
 256         ALC882_AUTO,
 257         ALC882_MODEL_LAST,
 258 };
 259
 260 /* ALC680 models */
 261 enum {
 262         ALC680_BASE,
 263         ALC680_AUTO,
 264         ALC680_MODEL_LAST,
 265 };
 266
 267 /* for GPIO Poll */
 268 #define GPIO_MASK       0x03
 269
 270 /* extra amp-initialization sequence types */
 271 enum {
 272         ALC_INIT_NONE,
 273         ALC_INIT_DEFAULT,
 274         ALC_INIT_GPIO1,
 275         ALC_INIT_GPIO2,
 276         ALC_INIT_GPIO3,
 277 };
 278
 279 struct alc_mic_route {
 280         hda_nid_t pin;
 281         unsigned char mux_idx;
 282         unsigned char amix_idx;
 283 };
 284
 285 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 286
 287 struct alc_customize_define {
 288         unsigned int  sku_cfg;
 289         unsigned char port_connectivity;
 290         unsigned char check_sum;
 291         unsigned char customization;
 292         unsigned char external_amp;
 293         unsigned int  enable_pcbeep:1;
 294         unsigned int  platform_type:1;
 295         unsigned int  swap:1;
 296         unsigned int  override:1;
 297 };
 298
 299 struct alc_spec {
 300         /* codec parameterization */
 301         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 302         unsigned int num_mixers;
 303         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 304         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 305
 306         const struct hda_verb *init_verbs[10];  /* initialization verbs
 307                                                  * don't forget NULL
 308                                                  * termination!
 309                                                  */
 310         unsigned int num_init_verbs;
 311
 312         char stream_name_analog[32];    /* analog PCM stream */
 313         struct hda_pcm_stream *stream_analog_playback;
 314         struct hda_pcm_stream *stream_analog_capture;
 315         struct hda_pcm_stream *stream_analog_alt_playback;
 316         struct hda_pcm_stream *stream_analog_alt_capture;
 317
 318         char stream_name_digital[32];   /* digital PCM stream */
 319         struct hda_pcm_stream *stream_digital_playback;
 320         struct hda_pcm_stream *stream_digital_capture;
 321
 322         /* playback */
 323         struct hda_multi_out multiout;  /* playback set-up
 324                                          * max_channels, dacs must be set
 325                                          * dig_out_nid and hp_nid are optional
 326                                          */
 327         hda_nid_t alt_dac_nid;
 328         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 329         int dig_out_type;
 330
 331         /* capture */
 332         unsigned int num_adc_nids;
 333         hda_nid_t *adc_nids;
 334         hda_nid_t *capsrc_nids;
 335         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 336
 337         /* capture setup for dynamic dual-adc switch */
 338         unsigned int cur_adc_idx;
 339         hda_nid_t cur_adc;
 340         unsigned int cur_adc_stream_tag;
 341         unsigned int cur_adc_format;
 342
 343         /* capture source */
 344         unsigned int num_mux_defs;
 345         const struct hda_input_mux *input_mux;
 346         unsigned int cur_mux[3];
 347         struct alc_mic_route ext_mic;
 348         struct alc_mic_route int_mic;
 349
 350         /* channel model */
 351         const struct hda_channel_mode *channel_mode;
 352         int num_channel_mode;
 353         int need_dac_fix;
 354         int const_channel_count;
 355         int ext_channel_count;
 356
 357         /* PCM information */
 358         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 359
 360         /* dynamic controls, init_verbs and input_mux */
 361         struct auto_pin_cfg autocfg;
 362         struct alc_customize_define cdefine;
 363         struct snd_array kctls;
 364         struct hda_input_mux private_imux[3];
 365         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 366         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 367         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 368
 369         /* hooks */
 370         void (*init_hook)(struct hda_codec *codec);
 371         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 372 #ifdef CONFIG_SND_HDA_POWER_SAVE
 373         void (*power_hook)(struct hda_codec *codec);
 374 #endif
 375
 376         /* for pin sensing */
 377         unsigned int sense_updated: 1;
 378         unsigned int jack_present: 1;
 379         unsigned int master_sw: 1;
 380         unsigned int auto_mic:1;
 381
 382         /* other flags */
 383         unsigned int no_analog :1; /* digital I/O only */
 384         unsigned int dual_adc_switch:1; /* switch ADCs (for ALC275) */
 385         int init_amp;
 386
 387         /* for virtual master */
 388         hda_nid_t vmaster_nid;
 389 #ifdef CONFIG_SND_HDA_POWER_SAVE
 390         struct hda_loopback_check loopback;
 391 #endif
 392
 393         /* for PLL fix */
 394         hda_nid_t pll_nid;
 395         unsigned int pll_coef_idx, pll_coef_bit;
 396 };
 397
 398 /*
 399  * configuration template - to be copied to the spec instance
 400  */
 401 struct alc_config_preset {
 402         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 403                                              * with spec
 404                                              */
 405         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 406         const struct hda_verb *init_verbs[5];
 407         unsigned int num_dacs;
 408         hda_nid_t *dac_nids;
 409         hda_nid_t dig_out_nid;          /* optional */
 410         hda_nid_t hp_nid;               /* optional */
 411         hda_nid_t *slave_dig_outs;
 412         unsigned int num_adc_nids;
 413         hda_nid_t *adc_nids;
 414         hda_nid_t *capsrc_nids;
 415         hda_nid_t dig_in_nid;
 416         unsigned int num_channel_mode;
 417         const struct hda_channel_mode *channel_mode;
 418         int need_dac_fix;
 419         int const_channel_count;
 420         unsigned int num_mux_defs;
 421         const struct hda_input_mux *input_mux;
 422         void (*unsol_event)(struct hda_codec *, unsigned int);
 423         void (*setup)(struct hda_codec *);
 424         void (*init_hook)(struct hda_codec *);
 425 #ifdef CONFIG_SND_HDA_POWER_SAVE
 426         struct hda_amp_list *loopbacks;
 427         void (*power_hook)(struct hda_codec *codec);
 428 #endif
 429 };
 430
 431
 432 /*
 433  * input MUX handling
 434  */
 435 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 436                              struct snd_ctl_elem_info *uinfo)
 437 {
 438         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 439         struct alc_spec *spec = codec->spec;
 440         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 441         if (mux_idx >= spec->num_mux_defs)
 442                 mux_idx = 0;
 443         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 444                 mux_idx = 0;
 445         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 446 }
 447
 448 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 449                             struct snd_ctl_elem_value *ucontrol)
 450 {
 451         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 452         struct alc_spec *spec = codec->spec;
 453         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 454
 455         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 456         return 0;
 457 }
 458
 459 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 460                             struct snd_ctl_elem_value *ucontrol)
 461 {
 462         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 463         struct alc_spec *spec = codec->spec;
 464         const struct hda_input_mux *imux;
 465         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 466         unsigned int mux_idx;
 467         hda_nid_t nid = spec->capsrc_nids ?
 468                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 469         unsigned int type;
 470
 471         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 472         imux = &spec->input_mux[mux_idx];
 473         if (!imux->num_items && mux_idx > 0)
 474                 imux = &spec->input_mux[0];
 475
 476         type = get_wcaps_type(get_wcaps(codec, nid));
 477         if (type == AC_WID_AUD_MIX) {
 478                 /* Matrix-mixer style (e.g. ALC882) */
 479                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 480                 unsigned int i, idx;
 481
 482                 idx = ucontrol->value.enumerated.item[0];
 483                 if (idx >= imux->num_items)
 484                         idx = imux->num_items - 1;
 485                 if (*cur_val == idx)
 486                         return 0;
 487                 for (i = 0; i < imux->num_items; i++) {
 488                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 489                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 490                                                  imux->items[i].index,
 491                                                  HDA_AMP_MUTE, v);
 492                 }
 493                 *cur_val = idx;
 494                 return 1;
 495         } else {
 496                 /* MUX style (e.g. ALC880) */
 497                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 498                                              &spec->cur_mux[adc_idx]);
 499         }
 500 }
 501
 502 /*
 503  * channel mode setting
 504  */
 505 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 506                             struct snd_ctl_elem_info *uinfo)
 507 {
 508         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 509         struct alc_spec *spec = codec->spec;
 510         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 511                                     spec->num_channel_mode);
 512 }
 513
 514 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 515                            struct snd_ctl_elem_value *ucontrol)
 516 {
 517         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 518         struct alc_spec *spec = codec->spec;
 519         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 520                                    spec->num_channel_mode,
 521                                    spec->ext_channel_count);
 522 }
 523
 524 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 525                            struct snd_ctl_elem_value *ucontrol)
 526 {
 527         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 528         struct alc_spec *spec = codec->spec;
 529         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 530                                       spec->num_channel_mode,
 531                                       &spec->ext_channel_count);
 532         if (err >= 0 && !spec->const_channel_count) {
 533                 spec->multiout.max_channels = spec->ext_channel_count;
 534                 if (spec->need_dac_fix)
 535                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 536         }
 537         return err;
 538 }
 539
 540 /*
 541  * Control the mode of pin widget settings via the mixer.  "pc" is used
 542  * instead of "%" to avoid consequences of accidently treating the % as
 543  * being part of a format specifier.  Maximum allowed length of a value is
 544  * 63 characters plus NULL terminator.
 545  *
 546  * Note: some retasking pin complexes seem to ignore requests for input
 547  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 548  * are requested.  Therefore order this list so that this behaviour will not
 549  * cause problems when mixer clients move through the enum sequentially.
 550  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 551  * March 2006.
 552  */
 553 static char *alc_pin_mode_names[] = {
 554         "Mic 50pc bias", "Mic 80pc bias",
 555         "Line in", "Line out", "Headphone out",
 556 };
 557 static unsigned char alc_pin_mode_values[] = {
 558         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 559 };
 560 /* The control can present all 5 options, or it can limit the options based
 561  * in the pin being assumed to be exclusively an input or an output pin.  In
 562  * addition, "input" pins may or may not process the mic bias option
 563  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 564  * accept requests for bias as of chip versions up to March 2006) and/or
 565  * wiring in the computer.
 566  */
 567 #define ALC_PIN_DIR_IN              0x00
 568 #define ALC_PIN_DIR_OUT             0x01
 569 #define ALC_PIN_DIR_INOUT           0x02
 570 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 571 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 572
 573 /* Info about the pin modes supported by the different pin direction modes.
 574  * For each direction the minimum and maximum values are given.
 575  */
 576 static signed char alc_pin_mode_dir_info[5][2] = {
 577         { 0, 2 },    /* ALC_PIN_DIR_IN */
 578         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 579         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 580         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 581         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 582 };
 583 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 584 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 585 #define alc_pin_mode_n_items(_dir) \
 586         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 587
 588 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 589                              struct snd_ctl_elem_info *uinfo)
 590 {
 591         unsigned int item_num = uinfo->value.enumerated.item;
 592         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 593
 594         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 595         uinfo->count = 1;
 596         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 597
 598         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 599                 item_num = alc_pin_mode_min(dir);
 600         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 601         return 0;
 602 }
 603
 604 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 605                             struct snd_ctl_elem_value *ucontrol)
 606 {
 607         unsigned int i;
 608         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 609         hda_nid_t nid = kcontrol->private_value & 0xffff;
 610         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 611         long *valp = ucontrol->value.integer.value;
 612         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 613                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 614                                                  0x00);
 615
 616         /* Find enumerated value for current pinctl setting */
 617         i = alc_pin_mode_min(dir);
 618         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 619                 i++;
 620         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 621         return 0;
 622 }
 623
 624 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 625                             struct snd_ctl_elem_value *ucontrol)
 626 {
 627         signed int change;
 628         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 629         hda_nid_t nid = kcontrol->private_value & 0xffff;
 630         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 631         long val = *ucontrol->value.integer.value;
 632         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 633                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 634                                                  0x00);
 635
 636         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 637                 val = alc_pin_mode_min(dir);
 638
 639         change = pinctl != alc_pin_mode_values[val];
 640         if (change) {
 641                 /* Set pin mode to that requested */
 642                 snd_hda_codec_write_cache(codec, nid, 0,
 643                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 644                                           alc_pin_mode_values[val]);
 645
 646                 /* Also enable the retasking pin's input/output as required
 647                  * for the requested pin mode.  Enum values of 2 or less are
 648                  * input modes.
 649                  *
 650                  * Dynamically switching the input/output buffers probably
 651                  * reduces noise slightly (particularly on input) so we'll
 652                  * do it.  However, having both input and output buffers
 653                  * enabled simultaneously doesn't seem to be problematic if
 654                  * this turns out to be necessary in the future.
 655                  */
 656                 if (val <= 2) {
 657                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 658                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 659                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 660                                                  HDA_AMP_MUTE, 0);
 661                 } else {
 662                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 663                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 664                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 665                                                  HDA_AMP_MUTE, 0);
 666                 }
 667         }
 668         return change;
 669 }
 670
 671 #define ALC_PIN_MODE(xname, nid, dir) \
 672         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 673           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 674           .info = alc_pin_mode_info, \
 675           .get = alc_pin_mode_get, \
 676           .put = alc_pin_mode_put, \
 677           .private_value = nid | (dir<<16) }
 678
 679 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 680  * together using a mask with more than one bit set.  This control is
 681  * currently used only by the ALC260 test model.  At this stage they are not
 682  * needed for any "production" models.
 683  */
 684 #ifdef CONFIG_SND_DEBUG
 685 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 686
 687 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 688                              struct snd_ctl_elem_value *ucontrol)
 689 {
 690         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 691         hda_nid_t nid = kcontrol->private_value & 0xffff;
 692         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 693         long *valp = ucontrol->value.integer.value;
 694         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 695                                               AC_VERB_GET_GPIO_DATA, 0x00);
 696
 697         *valp = (val & mask) != 0;
 698         return 0;
 699 }
 700 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 701                              struct snd_ctl_elem_value *ucontrol)
 702 {
 703         signed int change;
 704         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 705         hda_nid_t nid = kcontrol->private_value & 0xffff;
 706         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 707         long val = *ucontrol->value.integer.value;
 708         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 709                                                     AC_VERB_GET_GPIO_DATA,
 710                                                     0x00);
 711
 712         /* Set/unset the masked GPIO bit(s) as needed */
 713         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 714         if (val == 0)
 715                 gpio_data &= ~mask;
 716         else
 717                 gpio_data |= mask;
 718         snd_hda_codec_write_cache(codec, nid, 0,
 719                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 720
 721         return change;
 722 }
 723 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 724         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 725           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 726           .info = alc_gpio_data_info, \
 727           .get = alc_gpio_data_get, \
 728           .put = alc_gpio_data_put, \
 729           .private_value = nid | (mask<<16) }
 730 #endif   /* CONFIG_SND_DEBUG */
 731
 732 /* A switch control to allow the enabling of the digital IO pins on the
 733  * ALC260.  This is incredibly simplistic; the intention of this control is
 734  * to provide something in the test model allowing digital outputs to be
 735  * identified if present.  If models are found which can utilise these
 736  * outputs a more complete mixer control can be devised for those models if
 737  * necessary.
 738  */
 739 #ifdef CONFIG_SND_DEBUG
 740 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 741
 742 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 743                               struct snd_ctl_elem_value *ucontrol)
 744 {
 745         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 746         hda_nid_t nid = kcontrol->private_value & 0xffff;
 747         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 748         long *valp = ucontrol->value.integer.value;
 749         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 750                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 751
 752         *valp = (val & mask) != 0;
 753         return 0;
 754 }
 755 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 756                               struct snd_ctl_elem_value *ucontrol)
 757 {
 758         signed int change;
 759         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 760         hda_nid_t nid = kcontrol->private_value & 0xffff;
 761         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 762         long val = *ucontrol->value.integer.value;
 763         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 764                                                     AC_VERB_GET_DIGI_CONVERT_1,
 765                                                     0x00);
 766
 767         /* Set/unset the masked control bit(s) as needed */
 768         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 769         if (val==0)
 770                 ctrl_data &= ~mask;
 771         else
 772                 ctrl_data |= mask;
 773         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 774                                   ctrl_data);
 775
 776         return change;
 777 }
 778 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 779         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 780           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 781           .info = alc_spdif_ctrl_info, \
 782           .get = alc_spdif_ctrl_get, \
 783           .put = alc_spdif_ctrl_put, \
 784           .private_value = nid | (mask<<16) }
 785 #endif   /* CONFIG_SND_DEBUG */
 786
 787 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 788  * Again, this is only used in the ALC26x test models to help identify when
 789  * the EAPD line must be asserted for features to work.
 790  */
 791 #ifdef CONFIG_SND_DEBUG
 792 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 793
 794 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 795                               struct snd_ctl_elem_value *ucontrol)
 796 {
 797         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 798         hda_nid_t nid = kcontrol->private_value & 0xffff;
 799         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 800         long *valp = ucontrol->value.integer.value;
 801         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 802                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 803
 804         *valp = (val & mask) != 0;
 805         return 0;
 806 }
 807
 808 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 809                               struct snd_ctl_elem_value *ucontrol)
 810 {
 811         int change;
 812         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 813         hda_nid_t nid = kcontrol->private_value & 0xffff;
 814         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 815         long val = *ucontrol->value.integer.value;
 816         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 817                                                     AC_VERB_GET_EAPD_BTLENABLE,
 818                                                     0x00);
 819
 820         /* Set/unset the masked control bit(s) as needed */
 821         change = (!val ? 0 : mask) != (ctrl_data & mask);
 822         if (!val)
 823                 ctrl_data &= ~mask;
 824         else
 825                 ctrl_data |= mask;
 826         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 827                                   ctrl_data);
 828
 829         return change;
 830 }
 831
 832 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 833         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 834           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 835           .info = alc_eapd_ctrl_info, \
 836           .get = alc_eapd_ctrl_get, \
 837           .put = alc_eapd_ctrl_put, \
 838           .private_value = nid | (mask<<16) }
 839 #endif   /* CONFIG_SND_DEBUG */
 840
 841 /*
 842  * set up the input pin config (depending on the given auto-pin type)
 843  */
 844 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 845                               int auto_pin_type)
 846 {
 847         unsigned int val = PIN_IN;
 848
 849         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 850                 unsigned int pincap;
 851                 unsigned int oldval;
 852                 oldval = snd_hda_codec_read(codec, nid, 0,
 853                                             AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
 854                 pincap = snd_hda_query_pin_caps(codec, nid);
 855                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 856                 /* if the default pin setup is vref50, we give it priority */
 857                 if ((pincap & AC_PINCAP_VREF_80) && oldval != PIN_VREF50)
 858                         val = PIN_VREF80;
 859                 else if (pincap & AC_PINCAP_VREF_50)
 860                         val = PIN_VREF50;
 861                 else if (pincap & AC_PINCAP_VREF_100)
 862                         val = PIN_VREF100;
 863                 else if (pincap & AC_PINCAP_VREF_GRD)
 864                         val = PIN_VREFGRD;
 865         }
 866         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 867 }
 868
 869 /*
 870  */
 871 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 872 {
 873         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 874                 return;
 875         spec->mixers[spec->num_mixers++] = mix;
 876 }
 877
 878 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 879 {
 880         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 881                 return;
 882         spec->init_verbs[spec->num_init_verbs++] = verb;
 883 }
 884
 885 /*
 886  * set up from the preset table
 887  */
 888 static void setup_preset(struct hda_codec *codec,
 889                          const struct alc_config_preset *preset)
 890 {
 891         struct alc_spec *spec = codec->spec;
 892         int i;
 893
 894         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 895                 add_mixer(spec, preset->mixers[i]);
 896         spec->cap_mixer = preset->cap_mixer;
 897         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 898              i++)
 899                 add_verb(spec, preset->init_verbs[i]);
 900
 901         spec->channel_mode = preset->channel_mode;
 902         spec->num_channel_mode = preset->num_channel_mode;
 903         spec->need_dac_fix = preset->need_dac_fix;
 904         spec->const_channel_count = preset->const_channel_count;
 905
 906         if (preset->const_channel_count)
 907                 spec->multiout.max_channels = preset->const_channel_count;
 908         else
 909                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 910         spec->ext_channel_count = spec->channel_mode[0].channels;
 911
 912         spec->multiout.num_dacs = preset->num_dacs;
 913         spec->multiout.dac_nids = preset->dac_nids;
 914         spec->multiout.dig_out_nid = preset->dig_out_nid;
 915         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 916         spec->multiout.hp_nid = preset->hp_nid;
 917
 918         spec->num_mux_defs = preset->num_mux_defs;
 919         if (!spec->num_mux_defs)
 920                 spec->num_mux_defs = 1;
 921         spec->input_mux = preset->input_mux;
 922
 923         spec->num_adc_nids = preset->num_adc_nids;
 924         spec->adc_nids = preset->adc_nids;
 925         spec->capsrc_nids = preset->capsrc_nids;
 926         spec->dig_in_nid = preset->dig_in_nid;
 927
 928         spec->unsol_event = preset->unsol_event;
 929         spec->init_hook = preset->init_hook;
 930 #ifdef CONFIG_SND_HDA_POWER_SAVE
 931         spec->power_hook = preset->power_hook;
 932         spec->loopback.amplist = preset->loopbacks;
 933 #endif
 934
 935         if (preset->setup)
 936                 preset->setup(codec);
 937 }
 938
 939 /* Enable GPIO mask and set output */
 940 static struct hda_verb alc_gpio1_init_verbs[] = {
 941         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 942         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 943         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 944         { }
 945 };
 946
 947 static struct hda_verb alc_gpio2_init_verbs[] = {
 948         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 949         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 950         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 951         { }
 952 };
 953
 954 static struct hda_verb alc_gpio3_init_verbs[] = {
 955         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 956         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 957         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 958         { }
 959 };
 960
 961 /*
 962  * Fix hardware PLL issue
 963  * On some codecs, the analog PLL gating control must be off while
 964  * the default value is 1.
 965  */
 966 static void alc_fix_pll(struct hda_codec *codec)
 967 {
 968         struct alc_spec *spec = codec->spec;
 969         unsigned int val;
 970
 971         if (!spec->pll_nid)
 972                 return;
 973         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 974                             spec->pll_coef_idx);
 975         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 976                                  AC_VERB_GET_PROC_COEF, 0);
 977         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 978                             spec->pll_coef_idx);
 979         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 980                             val & ~(1 << spec->pll_coef_bit));
 981 }
 982
 983 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 984                              unsigned int coef_idx, unsigned int coef_bit)
 985 {
 986         struct alc_spec *spec = codec->spec;
 987         spec->pll_nid = nid;
 988         spec->pll_coef_idx = coef_idx;
 989         spec->pll_coef_bit = coef_bit;
 990         alc_fix_pll(codec);
 991 }
 992
 993 static void alc_automute_speaker(struct hda_codec *codec, int pinctl)
 994 {
 995         struct alc_spec *spec = codec->spec;
 996         unsigned int mute;
 997         hda_nid_t nid;
 998         int i;
 999
1000         spec->jack_present = 0;
1001         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1002                 nid = spec->autocfg.hp_pins[i];
1003                 if (!nid)
1004                         break;
1005                 if (snd_hda_jack_detect(codec, nid)) {
1006                         spec->jack_present = 1;
1007                         break;
1008                 }
1009         }
1010
1011         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1012         /* Toggle internal speakers muting */
1013         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1014                 nid = spec->autocfg.speaker_pins[i];
1015                 if (!nid)
1016                         break;
1017                 if (pinctl) {
1018                         snd_hda_codec_write(codec, nid, 0,
1019                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1020                                     spec->jack_present ? 0 : PIN_OUT);
1021                 } else {
1022                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1023                                          HDA_AMP_MUTE, mute);
1024                 }
1025         }
1026 }
1027
1028 static void alc_automute_pin(struct hda_codec *codec)
1029 {
1030         alc_automute_speaker(codec, 1);
1031 }
1032
1033 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
1034                                 hda_nid_t nid)
1035 {
1036         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
1037         int i, nums;
1038
1039         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
1040         for (i = 0; i < nums; i++)
1041                 if (conn[i] == nid)
1042                         return i;
1043         return -1;
1044 }
1045
1046 /* switch the current ADC according to the jack state */
1047 static void alc_dual_mic_adc_auto_switch(struct hda_codec *codec)
1048 {
1049         struct alc_spec *spec = codec->spec;
1050         unsigned int present;
1051         hda_nid_t new_adc;
1052
1053         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1054         if (present)
1055                 spec->cur_adc_idx = 1;
1056         else
1057                 spec->cur_adc_idx = 0;
1058         new_adc = spec->adc_nids[spec->cur_adc_idx];
1059         if (spec->cur_adc && spec->cur_adc != new_adc) {
1060                 /* stream is running, let's swap the current ADC */
1061                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
1062                 spec->cur_adc = new_adc;
1063                 snd_hda_codec_setup_stream(codec, new_adc,
1064                                            spec->cur_adc_stream_tag, 0,
1065                                            spec->cur_adc_format);
1066         }
1067 }
1068
1069 static void alc_mic_automute(struct hda_codec *codec)
1070 {
1071         struct alc_spec *spec = codec->spec;
1072         struct alc_mic_route *dead, *alive;
1073         unsigned int present, type;
1074         hda_nid_t cap_nid;
1075
1076         if (!spec->auto_mic)
1077                 return;
1078         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1079                 return;
1080         if (snd_BUG_ON(!spec->adc_nids))
1081                 return;
1082
1083         if (spec->dual_adc_switch) {
1084                 alc_dual_mic_adc_auto_switch(codec);
1085                 return;
1086         }
1087
1088         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1089
1090         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1091         if (present) {
1092                 alive = &spec->ext_mic;
1093                 dead = &spec->int_mic;
1094         } else {
1095                 alive = &spec->int_mic;
1096                 dead = &spec->ext_mic;
1097         }
1098
1099         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1100         if (type == AC_WID_AUD_MIX) {
1101                 /* Matrix-mixer style (e.g. ALC882) */
1102                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1103                                          alive->mux_idx,
1104                                          HDA_AMP_MUTE, 0);
1105                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1106                                          dead->mux_idx,
1107                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1108         } else {
1109                 /* MUX style (e.g. ALC880) */
1110                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1111                                           AC_VERB_SET_CONNECT_SEL,
1112                                           alive->mux_idx);
1113         }
1114
1115         /* FIXME: analog mixer */
1116 }
1117
1118 /* unsolicited event for HP jack sensing */
1119 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1120 {
1121         if (codec->vendor_id == 0x10ec0880)
1122                 res >>= 28;
1123         else
1124                 res >>= 26;
1125         switch (res) {
1126         case ALC880_HP_EVENT:
1127                 alc_automute_pin(codec);
1128                 break;
1129         case ALC880_MIC_EVENT:
1130                 alc_mic_automute(codec);
1131                 break;
1132         }
1133 }
1134
1135 static void alc_inithook(struct hda_codec *codec)
1136 {
1137         alc_automute_pin(codec);
1138         alc_mic_automute(codec);
1139 }
1140
1141 /* additional initialization for ALC888 variants */
1142 static void alc888_coef_init(struct hda_codec *codec)
1143 {
1144         unsigned int tmp;
1145
1146         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1147         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1148         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1149         if ((tmp & 0xf0) == 0x20)
1150                 /* alc888S-VC */
1151                 snd_hda_codec_read(codec, 0x20, 0,
1152                                    AC_VERB_SET_PROC_COEF, 0x830);
1153          else
1154                  /* alc888-VB */
1155                  snd_hda_codec_read(codec, 0x20, 0,
1156                                     AC_VERB_SET_PROC_COEF, 0x3030);
1157 }
1158
1159 static void alc889_coef_init(struct hda_codec *codec)
1160 {
1161         unsigned int tmp;
1162
1163         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1164         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1165         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1166         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1167 }
1168
1169 /* turn on/off EAPD control (only if available) */
1170 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1171 {
1172         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1173                 return;
1174         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1175                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1176                                     on ? 2 : 0);
1177 }
1178
1179 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1180 {
1181         unsigned int tmp;
1182
1183         switch (type) {
1184         case ALC_INIT_GPIO1:
1185                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1186                 break;
1187         case ALC_INIT_GPIO2:
1188                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1189                 break;
1190         case ALC_INIT_GPIO3:
1191                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1192                 break;
1193         case ALC_INIT_DEFAULT:
1194                 switch (codec->vendor_id) {
1195                 case 0x10ec0260:
1196                         set_eapd(codec, 0x0f, 1);
1197                         set_eapd(codec, 0x10, 1);
1198                         break;
1199                 case 0x10ec0262:
1200                 case 0x10ec0267:
1201                 case 0x10ec0268:
1202                 case 0x10ec0269:
1203                 case 0x10ec0270:
1204                 case 0x10ec0272:
1205                 case 0x10ec0660:
1206                 case 0x10ec0662:
1207                 case 0x10ec0663:
1208                 case 0x10ec0862:
1209                 case 0x10ec0889:
1210                         set_eapd(codec, 0x14, 1);
1211                         set_eapd(codec, 0x15, 1);
1212                         break;
1213                 }
1214                 switch (codec->vendor_id) {
1215                 case 0x10ec0260:
1216                         snd_hda_codec_write(codec, 0x1a, 0,
1217                                             AC_VERB_SET_COEF_INDEX, 7);
1218                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1219                                                  AC_VERB_GET_PROC_COEF, 0);
1220                         snd_hda_codec_write(codec, 0x1a, 0,
1221                                             AC_VERB_SET_COEF_INDEX, 7);
1222                         snd_hda_codec_write(codec, 0x1a, 0,
1223                                             AC_VERB_SET_PROC_COEF,
1224                                             tmp | 0x2010);
1225                         break;
1226                 case 0x10ec0262:
1227                 case 0x10ec0880:
1228                 case 0x10ec0882:
1229                 case 0x10ec0883:
1230                 case 0x10ec0885:
1231                 case 0x10ec0887:
1232                 case 0x10ec0889:
1233                         alc889_coef_init(codec);
1234                         break;
1235                 case 0x10ec0888:
1236                         alc888_coef_init(codec);
1237                         break;
1238 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1239                 case 0x10ec0267:
1240                 case 0x10ec0268:
1241                         snd_hda_codec_write(codec, 0x20, 0,
1242                                             AC_VERB_SET_COEF_INDEX, 7);
1243                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1244                                                  AC_VERB_GET_PROC_COEF, 0);
1245                         snd_hda_codec_write(codec, 0x20, 0,
1246                                             AC_VERB_SET_COEF_INDEX, 7);
1247                         snd_hda_codec_write(codec, 0x20, 0,
1248                                             AC_VERB_SET_PROC_COEF,
1249                                             tmp | 0x3000);
1250                         break;
1251 #endif /* XXX */
1252                 }
1253                 break;
1254         }
1255 }
1256
1257 static void alc_init_auto_hp(struct hda_codec *codec)
1258 {
1259         struct alc_spec *spec = codec->spec;
1260         struct auto_pin_cfg *cfg = &spec->autocfg;
1261         int i;
1262
1263         if (!cfg->hp_pins[0]) {
1264                 if (cfg->line_out_type != AUTO_PIN_HP_OUT)
1265                         return;
1266         }
1267
1268         if (!cfg->speaker_pins[0]) {
1269                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT)
1270                         return;
1271                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
1272                        sizeof(cfg->speaker_pins));
1273                 cfg->speaker_outs = cfg->line_outs;
1274         }
1275
1276         if (!cfg->hp_pins[0]) {
1277                 memcpy(cfg->hp_pins, cfg->line_out_pins,
1278                        sizeof(cfg->hp_pins));
1279                 cfg->hp_outs = cfg->line_outs;
1280         }
1281
1282         for (i = 0; i < cfg->hp_outs; i++) {
1283                 snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1284                             cfg->hp_pins[i]);
1285                 snd_hda_codec_write_cache(codec, cfg->hp_pins[i], 0,
1286                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1287                                   AC_USRSP_EN | ALC880_HP_EVENT);
1288         }
1289         spec->unsol_event = alc_sku_unsol_event;
1290 }
1291
1292 static void alc_init_auto_mic(struct hda_codec *codec)
1293 {
1294         struct alc_spec *spec = codec->spec;
1295         struct auto_pin_cfg *cfg = &spec->autocfg;
1296         hda_nid_t fixed, ext;
1297         int i;
1298
1299         /* there must be only two mic inputs exclusively */
1300         for (i = 0; i < cfg->num_inputs; i++)
1301                 if (cfg->inputs[i].type >= AUTO_PIN_LINE)
1302                         return;
1303
1304         fixed = ext = 0;
1305         for (i = 0; i < cfg->num_inputs; i++) {
1306                 hda_nid_t nid = cfg->inputs[i].pin;
1307                 unsigned int defcfg;
1308                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1309                 switch (get_defcfg_connect(defcfg)) {
1310                 case AC_JACK_PORT_FIXED:
1311                         if (fixed)
1312                                 return; /* already occupied */
1313                         fixed = nid;
1314                         break;
1315                 case AC_JACK_PORT_COMPLEX:
1316                         if (ext)
1317                                 return; /* already occupied */
1318                         ext = nid;
1319                         break;
1320                 default:
1321                         return; /* invalid entry */
1322                 }
1323         }
1324         if (!ext || !fixed)
1325                 return;
1326         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1327                 return; /* no unsol support */
1328         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1329                     ext, fixed);
1330         spec->ext_mic.pin = ext;
1331         spec->int_mic.pin = fixed;
1332         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1333         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1334         spec->auto_mic = 1;
1335         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1336                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1337                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1338         spec->unsol_event = alc_sku_unsol_event;
1339 }
1340
1341 static int alc_auto_parse_customize_define(struct hda_codec *codec)
1342 {
1343         unsigned int ass, tmp, i;
1344         unsigned nid = 0;
1345         struct alc_spec *spec = codec->spec;
1346
1347         spec->cdefine.enable_pcbeep = 1; /* assume always enabled */
1348
1349         ass = codec->subsystem_id & 0xffff;
1350         if (ass != codec->bus->pci->subsystem_device && (ass & 1))
1351                 goto do_sku;
1352
1353         nid = 0x1d;
1354         if (codec->vendor_id == 0x10ec0260)
1355                 nid = 0x17;
1356         ass = snd_hda_codec_get_pincfg(codec, nid);
1357
1358         if (!(ass & 1)) {
1359                 printk(KERN_INFO "hda_codec: %s: SKU not ready 0x%08x\n",
1360                        codec->chip_name, ass);
1361                 return -1;
1362         }
1363
1364         /* check sum */
1365         tmp = 0;
1366         for (i = 1; i < 16; i++) {
1367                 if ((ass >> i) & 1)
1368                         tmp++;
1369         }
1370         if (((ass >> 16) & 0xf) != tmp)
1371                 return -1;
1372
1373         spec->cdefine.port_connectivity = ass >> 30;
1374         spec->cdefine.enable_pcbeep = (ass & 0x100000) >> 20;
1375         spec->cdefine.check_sum = (ass >> 16) & 0xf;
1376         spec->cdefine.customization = ass >> 8;
1377 do_sku:
1378         spec->cdefine.sku_cfg = ass;
1379         spec->cdefine.external_amp = (ass & 0x38) >> 3;
1380         spec->cdefine.platform_type = (ass & 0x4) >> 2;
1381         spec->cdefine.swap = (ass & 0x2) >> 1;
1382         spec->cdefine.override = ass & 0x1;
1383
1384         snd_printd("SKU: Nid=0x%x sku_cfg=0x%08x\n",
1385                    nid, spec->cdefine.sku_cfg);
1386         snd_printd("SKU: port_connectivity=0x%x\n",
1387                    spec->cdefine.port_connectivity);
1388         snd_printd("SKU: enable_pcbeep=0x%x\n", spec->cdefine.enable_pcbeep);
1389         snd_printd("SKU: check_sum=0x%08x\n", spec->cdefine.check_sum);
1390         snd_printd("SKU: customization=0x%08x\n", spec->cdefine.customization);
1391         snd_printd("SKU: external_amp=0x%x\n", spec->cdefine.external_amp);
1392         snd_printd("SKU: platform_type=0x%x\n", spec->cdefine.platform_type);
1393         snd_printd("SKU: swap=0x%x\n", spec->cdefine.swap);
1394         snd_printd("SKU: override=0x%x\n", spec->cdefine.override);
1395
1396         return 0;
1397 }
1398
1399 /* check subsystem ID and set up device-specific initialization;
1400  * return 1 if initialized, 0 if invalid SSID
1401  */
1402 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1403  *      31 ~ 16 :       Manufacture ID
1404  *      15 ~ 8  :       SKU ID
1405  *      7  ~ 0  :       Assembly ID
1406  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1407  */
1408 static int alc_subsystem_id(struct hda_codec *codec,
1409                             hda_nid_t porta, hda_nid_t porte,
1410                             hda_nid_t portd, hda_nid_t porti)
1411 {
1412         unsigned int ass, tmp, i;
1413         unsigned nid;
1414         struct alc_spec *spec = codec->spec;
1415
1416         ass = codec->subsystem_id & 0xffff;
1417         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1418                 goto do_sku;
1419
1420         /* invalid SSID, check the special NID pin defcfg instead */
1421         /*
1422          * 31~30        : port connectivity
1423          * 29~21        : reserve
1424          * 20           : PCBEEP input
1425          * 19~16        : Check sum (15:1)
1426          * 15~1         : Custom
1427          * 0            : override
1428         */
1429         nid = 0x1d;
1430         if (codec->vendor_id == 0x10ec0260)
1431                 nid = 0x17;
1432         ass = snd_hda_codec_get_pincfg(codec, nid);
1433         snd_printd("realtek: No valid SSID, "
1434                    "checking pincfg 0x%08x for NID 0x%x\n",
1435                    ass, nid);
1436         if (!(ass & 1))
1437                 return 0;
1438         if ((ass >> 30) != 1)   /* no physical connection */
1439                 return 0;
1440
1441         /* check sum */
1442         tmp = 0;
1443         for (i = 1; i < 16; i++) {
1444                 if ((ass >> i) & 1)
1445                         tmp++;
1446         }
1447         if (((ass >> 16) & 0xf) != tmp)
1448                 return 0;
1449 do_sku:
1450         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1451                    ass & 0xffff, codec->vendor_id);
1452         /*
1453          * 0 : override
1454          * 1 :  Swap Jack
1455          * 2 : 0 --> Desktop, 1 --> Laptop
1456          * 3~5 : External Amplifier control
1457          * 7~6 : Reserved
1458         */
1459         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1460         switch (tmp) {
1461         case 1:
1462                 spec->init_amp = ALC_INIT_GPIO1;
1463                 break;
1464         case 3:
1465                 spec->init_amp = ALC_INIT_GPIO2;
1466                 break;
1467         case 7:
1468                 spec->init_amp = ALC_INIT_GPIO3;
1469                 break;
1470         case 5:
1471                 spec->init_amp = ALC_INIT_DEFAULT;
1472                 break;
1473         }
1474
1475         /* is laptop or Desktop and enable the function "Mute internal speaker
1476          * when the external headphone out jack is plugged"
1477          */
1478         if (!(ass & 0x8000))
1479                 return 1;
1480         /*
1481          * 10~8 : Jack location
1482          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1483          * 14~13: Resvered
1484          * 15   : 1 --> enable the function "Mute internal speaker
1485          *              when the external headphone out jack is plugged"
1486          */
1487         if (!spec->autocfg.hp_pins[0]) {
1488                 hda_nid_t nid;
1489                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1490                 if (tmp == 0)
1491                         nid = porta;
1492                 else if (tmp == 1)
1493                         nid = porte;
1494                 else if (tmp == 2)
1495                         nid = portd;
1496                 else if (tmp == 3)
1497                         nid = porti;
1498                 else
1499                         return 1;
1500                 for (i = 0; i < spec->autocfg.line_outs; i++)
1501                         if (spec->autocfg.line_out_pins[i] == nid)
1502                                 return 1;
1503                 spec->autocfg.hp_pins[0] = nid;
1504         }
1505
1506         alc_init_auto_hp(codec);
1507         alc_init_auto_mic(codec);
1508         return 1;
1509 }
1510
1511 static void alc_ssid_check(struct hda_codec *codec,
1512                            hda_nid_t porta, hda_nid_t porte,
1513                            hda_nid_t portd, hda_nid_t porti)
1514 {
1515         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1516                 struct alc_spec *spec = codec->spec;
1517                 snd_printd("realtek: "
1518                            "Enable default setup for auto mode as fallback\n");
1519                 spec->init_amp = ALC_INIT_DEFAULT;
1520                 alc_init_auto_hp(codec);
1521                 alc_init_auto_mic(codec);
1522         }
1523 }
1524
1525 /*
1526  * Fix-up pin default configurations and add default verbs
1527  */
1528
1529 struct alc_pincfg {
1530         hda_nid_t nid;
1531         u32 val;
1532 };
1533
1534 struct alc_fixup {
1535         const struct alc_pincfg *pins;
1536         const struct hda_verb *verbs;
1537 };
1538
1539 static void alc_pick_fixup(struct hda_codec *codec,
1540                            const struct snd_pci_quirk *quirk,
1541                            const struct alc_fixup *fix,
1542                            int pre_init)
1543 {
1544         const struct alc_pincfg *cfg;
1545
1546         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1547         if (!quirk)
1548                 return;
1549         fix += quirk->value;
1550         cfg = fix->pins;
1551         if (pre_init && cfg) {
1552 #ifdef CONFIG_SND_DEBUG_VERBOSE
1553                 snd_printdd(KERN_INFO "hda_codec: %s: Apply pincfg for %s\n",
1554                             codec->chip_name, quirk->name);
1555 #endif
1556                 for (; cfg->nid; cfg++)
1557                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1558         }
1559         if (!pre_init && fix->verbs) {
1560 #ifdef CONFIG_SND_DEBUG_VERBOSE
1561                 snd_printdd(KERN_INFO "hda_codec: %s: Apply fix-verbs for %s\n",
1562                             codec->chip_name, quirk->name);
1563 #endif
1564                 add_verb(codec->spec, fix->verbs);
1565         }
1566 }
1567
1568 static int alc_read_coef_idx(struct hda_codec *codec,
1569                         unsigned int coef_idx)
1570 {
1571         unsigned int val;
1572         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1573                                 coef_idx);
1574         val = snd_hda_codec_read(codec, 0x20, 0,
1575                                 AC_VERB_GET_PROC_COEF, 0);
1576         return val;
1577 }
1578
1579 /* set right pin controls for digital I/O */
1580 static void alc_auto_init_digital(struct hda_codec *codec)
1581 {
1582         struct alc_spec *spec = codec->spec;
1583         int i;
1584         hda_nid_t pin;
1585
1586         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1587                 pin = spec->autocfg.dig_out_pins[i];
1588                 if (pin) {
1589                         snd_hda_codec_write(codec, pin, 0,
1590                                             AC_VERB_SET_PIN_WIDGET_CONTROL,
1591                                             PIN_OUT);
1592                 }
1593         }
1594         pin = spec->autocfg.dig_in_pin;
1595         if (pin)
1596                 snd_hda_codec_write(codec, pin, 0,
1597                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
1598                                     PIN_IN);
1599 }
1600
1601 /* parse digital I/Os and set up NIDs in BIOS auto-parse mode */
1602 static void alc_auto_parse_digital(struct hda_codec *codec)
1603 {
1604         struct alc_spec *spec = codec->spec;
1605         int i, err;
1606         hda_nid_t dig_nid;
1607
1608         /* support multiple SPDIFs; the secondary is set up as a slave */
1609         for (i = 0; i < spec->autocfg.dig_outs; i++) {
1610                 err = snd_hda_get_connections(codec,
1611                                               spec->autocfg.dig_out_pins[i],
1612                                               &dig_nid, 1);
1613                 if (err < 0)
1614                         continue;
1615                 if (!i) {
1616                         spec->multiout.dig_out_nid = dig_nid;
1617                         spec->dig_out_type = spec->autocfg.dig_out_type[0];
1618                 } else {
1619                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
1620                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
1621                                 break;
1622                         spec->slave_dig_outs[i - 1] = dig_nid;
1623                 }
1624         }
1625
1626         if (spec->autocfg.dig_in_pin) {
1627                 hda_nid_t dig_nid;
1628                 err = snd_hda_get_connections(codec,
1629                                               spec->autocfg.dig_in_pin,
1630                                               &dig_nid, 1);
1631                 if (err > 0)
1632                         spec->dig_in_nid = dig_nid;
1633         }
1634 }
1635
1636 /*
1637  * ALC888
1638  */
1639
1640 /*
1641  * 2ch mode
1642  */
1643 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1644 /* Mic-in jack as mic in */
1645         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1646         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1647 /* Line-in jack as Line in */
1648         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1649         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1650 /* Line-Out as Front */
1651         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1652         { } /* end */
1653 };
1654
1655 /*
1656  * 4ch mode
1657  */
1658 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1659 /* Mic-in jack as mic in */
1660         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1661         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1662 /* Line-in jack as Surround */
1663         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1664         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1665 /* Line-Out as Front */
1666         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1667         { } /* end */
1668 };
1669
1670 /*
1671  * 6ch mode
1672  */
1673 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1674 /* Mic-in jack as CLFE */
1675         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1676         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1677 /* Line-in jack as Surround */
1678         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1679         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1680 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1681         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1682         { } /* end */
1683 };
1684
1685 /*
1686  * 8ch mode
1687  */
1688 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1689 /* Mic-in jack as CLFE */
1690         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1691         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1692 /* Line-in jack as Surround */
1693         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1694         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1695 /* Line-Out as Side */
1696         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1697         { } /* end */
1698 };
1699
1700 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1701         { 2, alc888_4ST_ch2_intel_init },
1702         { 4, alc888_4ST_ch4_intel_init },
1703         { 6, alc888_4ST_ch6_intel_init },
1704         { 8, alc888_4ST_ch8_intel_init },
1705 };
1706
1707 /*
1708  * ALC888 Fujitsu Siemens Amillo xa3530
1709  */
1710
1711 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1712 /* Front Mic: set to PIN_IN (empty by default) */
1713         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1714 /* Connect Internal HP to Front */
1715         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1716         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1717         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1718 /* Connect Bass HP to Front */
1719         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1720         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1721         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1722 /* Connect Line-Out side jack (SPDIF) to Side */
1723         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1724         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1725         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1726 /* Connect Mic jack to CLFE */
1727         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1728         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1729         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1730 /* Connect Line-in jack to Surround */
1731         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1732         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1733         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1734 /* Connect HP out jack to Front */
1735         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1736         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1737         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1738 /* Enable unsolicited event for HP jack and Line-out jack */
1739         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1740         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1741         {}
1742 };
1743
1744 static void alc_automute_amp(struct hda_codec *codec)
1745 {
1746         alc_automute_speaker(codec, 0);
1747 }
1748
1749 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1750                                          unsigned int res)
1751 {
1752         if (codec->vendor_id == 0x10ec0880)
1753                 res >>= 28;
1754         else
1755                 res >>= 26;
1756         if (res == ALC880_HP_EVENT)
1757                 alc_automute_amp(codec);
1758 }
1759
1760 static void alc889_automute_setup(struct hda_codec *codec)
1761 {
1762         struct alc_spec *spec = codec->spec;
1763
1764         spec->autocfg.hp_pins[0] = 0x15;
1765         spec->autocfg.speaker_pins[0] = 0x14;
1766         spec->autocfg.speaker_pins[1] = 0x16;
1767         spec->autocfg.speaker_pins[2] = 0x17;
1768         spec->autocfg.speaker_pins[3] = 0x19;
1769         spec->autocfg.speaker_pins[4] = 0x1a;
1770 }
1771
1772 static void alc889_intel_init_hook(struct hda_codec *codec)
1773 {
1774         alc889_coef_init(codec);
1775         alc_automute_amp(codec);
1776 }
1777
1778 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1779 {
1780         struct alc_spec *spec = codec->spec;
1781
1782         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1783         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1784         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1785         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1786 }
1787
1788 /*
1789  * ALC888 Acer Aspire 4930G model
1790  */
1791
1792 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1793 /* Front Mic: set to PIN_IN (empty by default) */
1794         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1795 /* Unselect Front Mic by default in input mixer 3 */
1796         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1797 /* Enable unsolicited event for HP jack */
1798         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1799 /* Connect Internal HP to front */
1800         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1801         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1802         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1803 /* Connect HP out to front */
1804         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1805         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1806         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1807         { }
1808 };
1809
1810 /*
1811  * ALC888 Acer Aspire 6530G model
1812  */
1813
1814 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1815 /* Route to built-in subwoofer as well as speakers */
1816         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1817         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1818         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1819         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1820 /* Bias voltage on for external mic port */
1821         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1822 /* Front Mic: set to PIN_IN (empty by default) */
1823         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1824 /* Unselect Front Mic by default in input mixer 3 */
1825         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1826 /* Enable unsolicited event for HP jack */
1827         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1828 /* Enable speaker output */
1829         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1830         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1831         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1832 /* Enable headphone output */
1833         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1834         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1835         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1836         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1837         { }
1838 };
1839
1840 /*
1841  * ALC889 Acer Aspire 8930G model
1842  */
1843
1844 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1845 /* Front Mic: set to PIN_IN (empty by default) */
1846         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1847 /* Unselect Front Mic by default in input mixer 3 */
1848         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1849 /* Enable unsolicited event for HP jack */
1850         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1851 /* Connect Internal Front to Front */
1852         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1853         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1854         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1855 /* Connect Internal Rear to Rear */
1856         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1857         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1858         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1859 /* Connect Internal CLFE to CLFE */
1860         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1861         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1862         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1863 /* Connect HP out to Front */
1864         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1865         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1866         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1867 /* Enable all DACs */
1868 /*  DAC DISABLE/MUTE 1? */
1869 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1870         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1871         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1872 /*  DAC DISABLE/MUTE 2? */
1873 /*  some bit here disables the other DACs. Init=0x4900 */
1874         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1875         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1876 /* DMIC fix
1877  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1878  * which makes the stereo useless. However, either the mic or the ALC889
1879  * makes the signal become a difference/sum signal instead of standard
1880  * stereo, which is annoying. So instead we flip this bit which makes the
1881  * codec replicate the sum signal to both channels, turning it into a
1882  * normal mono mic.
1883  */
1884 /*  DMIC_CONTROL? Init value = 0x0001 */
1885         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1886         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1887         { }
1888 };
1889
1890 static struct hda_input_mux alc888_2_capture_sources[2] = {
1891         /* Front mic only available on one ADC */
1892         {
1893                 .num_items = 4,
1894                 .items = {
1895                         { "Mic", 0x0 },
1896                         { "Line", 0x2 },
1897                         { "CD", 0x4 },
1898                         { "Front Mic", 0xb },
1899                 },
1900         },
1901         {
1902                 .num_items = 3,
1903                 .items = {
1904                         { "Mic", 0x0 },
1905                         { "Line", 0x2 },
1906                         { "CD", 0x4 },
1907                 },
1908         }
1909 };
1910
1911 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1912         /* Interal mic only available on one ADC */
1913         {
1914                 .num_items = 5,
1915                 .items = {
1916                         { "Ext Mic", 0x0 },
1917                         { "Line In", 0x2 },
1918                         { "CD", 0x4 },
1919                         { "Input Mix", 0xa },
1920                         { "Int Mic", 0xb },
1921                 },
1922         },
1923         {
1924                 .num_items = 4,
1925                 .items = {
1926                         { "Ext Mic", 0x0 },
1927                         { "Line In", 0x2 },
1928                         { "CD", 0x4 },
1929                         { "Input Mix", 0xa },
1930                 },
1931         }
1932 };
1933
1934 static struct hda_input_mux alc889_capture_sources[3] = {
1935         /* Digital mic only available on first "ADC" */
1936         {
1937                 .num_items = 5,
1938                 .items = {
1939                         { "Mic", 0x0 },
1940                         { "Line", 0x2 },
1941                         { "CD", 0x4 },
1942                         { "Front Mic", 0xb },
1943                         { "Input Mix", 0xa },
1944                 },
1945         },
1946         {
1947                 .num_items = 4,
1948                 .items = {
1949                         { "Mic", 0x0 },
1950                         { "Line", 0x2 },
1951                         { "CD", 0x4 },
1952                         { "Input Mix", 0xa },
1953                 },
1954         },
1955         {
1956                 .num_items = 4,
1957                 .items = {
1958                         { "Mic", 0x0 },
1959                         { "Line", 0x2 },
1960                         { "CD", 0x4 },
1961                         { "Input Mix", 0xa },
1962                 },
1963         }
1964 };
1965
1966 static struct snd_kcontrol_new alc888_base_mixer[] = {
1967         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1968         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1969         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1970         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1971         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1972                 HDA_OUTPUT),
1973         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1974         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1975         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1976         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1977         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1978         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1979         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1980         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1981         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1982         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1983         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1984         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1985         { } /* end */
1986 };
1987
1988 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1989         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1990         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1991         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1992         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1993         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1994                 HDA_OUTPUT),
1995         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1996         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1997         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1998         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1999         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2000         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2001         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
2002         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2003         { } /* end */
2004 };
2005
2006
2007 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
2008 {
2009         struct alc_spec *spec = codec->spec;
2010
2011         spec->autocfg.hp_pins[0] = 0x15;
2012         spec->autocfg.speaker_pins[0] = 0x14;
2013         spec->autocfg.speaker_pins[1] = 0x16;
2014         spec->autocfg.speaker_pins[2] = 0x17;
2015 }
2016
2017 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
2018 {
2019         struct alc_spec *spec = codec->spec;
2020
2021         spec->autocfg.hp_pins[0] = 0x15;
2022         spec->autocfg.speaker_pins[0] = 0x14;
2023         spec->autocfg.speaker_pins[1] = 0x16;
2024         spec->autocfg.speaker_pins[2] = 0x17;
2025 }
2026
2027 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
2028 {
2029         struct alc_spec *spec = codec->spec;
2030
2031         spec->autocfg.hp_pins[0] = 0x15;
2032         spec->autocfg.speaker_pins[0] = 0x14;
2033         spec->autocfg.speaker_pins[1] = 0x16;
2034         spec->autocfg.speaker_pins[2] = 0x1b;
2035 }
2036
2037 /*
2038  * ALC880 3-stack model
2039  *
2040  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
2041  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
2042  *                 F-Mic = 0x1b, HP = 0x19
2043  */
2044
2045 static hda_nid_t alc880_dac_nids[4] = {
2046         /* front, rear, clfe, rear_surr */
2047         0x02, 0x05, 0x04, 0x03
2048 };
2049
2050 static hda_nid_t alc880_adc_nids[3] = {
2051         /* ADC0-2 */
2052         0x07, 0x08, 0x09,
2053 };
2054
2055 /* The datasheet says the node 0x07 is connected from inputs,
2056  * but it shows zero connection in the real implementation on some devices.
2057  * Note: this is a 915GAV bug, fixed on 915GLV
2058  */
2059 static hda_nid_t alc880_adc_nids_alt[2] = {
2060         /* ADC1-2 */
2061         0x08, 0x09,
2062 };
2063
2064 #define ALC880_DIGOUT_NID       0x06
2065 #define ALC880_DIGIN_NID        0x0a
2066
2067 static struct hda_input_mux alc880_capture_source = {
2068         .num_items = 4,
2069         .items = {
2070                 { "Mic", 0x0 },
2071                 { "Front Mic", 0x3 },
2072                 { "Line", 0x2 },
2073                 { "CD", 0x4 },
2074         },
2075 };
2076
2077 /* channel source setting (2/6 channel selection for 3-stack) */
2078 /* 2ch mode */
2079 static struct hda_verb alc880_threestack_ch2_init[] = {
2080         /* set line-in to input, mute it */
2081         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2082         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2083         /* set mic-in to input vref 80%, mute it */
2084         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
2085         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2086         { } /* end */
2087 };
2088
2089 /* 6ch mode */
2090 static struct hda_verb alc880_threestack_ch6_init[] = {
2091         /* set line-in to output, unmute it */
2092         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2093         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2094         /* set mic-in to output, unmute it */
2095         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2096         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2097         { } /* end */
2098 };
2099
2100 static struct hda_channel_mode alc880_threestack_modes[2] = {
2101         { 2, alc880_threestack_ch2_init },
2102         { 6, alc880_threestack_ch6_init },
2103 };
2104
2105 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
2106         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2107         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2108         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2109         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
2110         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2111         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2112         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2113         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2114         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2115         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2116         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2117         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2118         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2119         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2120         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
2121         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
2122         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
2123         {
2124                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2125                 .name = "Channel Mode",
2126                 .info = alc_ch_mode_info,
2127                 .get = alc_ch_mode_get,
2128                 .put = alc_ch_mode_put,
2129         },
2130         { } /* end */
2131 };
2132
2133 /* capture mixer elements */
2134 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
2135                             struct snd_ctl_elem_info *uinfo)
2136 {
2137         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2138         struct alc_spec *spec = codec->spec;
2139         int err;
2140
2141         mutex_lock(&codec->control_mutex);
2142         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2143                                                       HDA_INPUT);
2144         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
2145         mutex_unlock(&codec->control_mutex);
2146         return err;
2147 }
2148
2149 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
2150                            unsigned int size, unsigned int __user *tlv)
2151 {
2152         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2153         struct alc_spec *spec = codec->spec;
2154         int err;
2155
2156         mutex_lock(&codec->control_mutex);
2157         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
2158                                                       HDA_INPUT);
2159         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
2160         mutex_unlock(&codec->control_mutex);
2161         return err;
2162 }
2163
2164 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
2165                              struct snd_ctl_elem_value *ucontrol);
2166
2167 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
2168                                  struct snd_ctl_elem_value *ucontrol,
2169                                  getput_call_t func)
2170 {
2171         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
2172         struct alc_spec *spec = codec->spec;
2173         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
2174         int err;
2175
2176         mutex_lock(&codec->control_mutex);
2177         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
2178                                                       3, 0, HDA_INPUT);
2179         err = func(kcontrol, ucontrol);
2180         mutex_unlock(&codec->control_mutex);
2181         return err;
2182 }
2183
2184 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
2185                            struct snd_ctl_elem_value *ucontrol)
2186 {
2187         return alc_cap_getput_caller(kcontrol, ucontrol,
2188                                      snd_hda_mixer_amp_volume_get);
2189 }
2190
2191 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2192                            struct snd_ctl_elem_value *ucontrol)
2193 {
2194         return alc_cap_getput_caller(kcontrol, ucontrol,
2195                                      snd_hda_mixer_amp_volume_put);
2196 }
2197
2198 /* capture mixer elements */
2199 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2200
2201 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2202                           struct snd_ctl_elem_value *ucontrol)
2203 {
2204         return alc_cap_getput_caller(kcontrol, ucontrol,
2205                                      snd_hda_mixer_amp_switch_get);
2206 }
2207
2208 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2209                           struct snd_ctl_elem_value *ucontrol)
2210 {
2211         return alc_cap_getput_caller(kcontrol, ucontrol,
2212                                      snd_hda_mixer_amp_switch_put);
2213 }
2214
2215 #define _DEFINE_CAPMIX(num) \
2216         { \
2217                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2218                 .name = "Capture Switch", \
2219                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2220                 .count = num, \
2221                 .info = alc_cap_sw_info, \
2222                 .get = alc_cap_sw_get, \
2223                 .put = alc_cap_sw_put, \
2224         }, \
2225         { \
2226                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2227                 .name = "Capture Volume", \
2228                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2229                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2230                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2231                 .count = num, \
2232                 .info = alc_cap_vol_info, \
2233                 .get = alc_cap_vol_get, \
2234                 .put = alc_cap_vol_put, \
2235                 .tlv = { .c = alc_cap_vol_tlv }, \
2236         }
2237
2238 #define _DEFINE_CAPSRC(num) \
2239         { \
2240                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2241                 /* .name = "Capture Source", */ \
2242                 .name = "Input Source", \
2243                 .count = num, \
2244                 .info = alc_mux_enum_info, \
2245                 .get = alc_mux_enum_get, \
2246                 .put = alc_mux_enum_put, \
2247         }
2248
2249 #define DEFINE_CAPMIX(num) \
2250 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2251         _DEFINE_CAPMIX(num),                                  \
2252         _DEFINE_CAPSRC(num),                                  \
2253         { } /* end */                                         \
2254 }
2255
2256 #define DEFINE_CAPMIX_NOSRC(num) \
2257 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2258         _DEFINE_CAPMIX(num),                                        \
2259         { } /* end */                                               \
2260 }
2261
2262 /* up to three ADCs */
2263 DEFINE_CAPMIX(1);
2264 DEFINE_CAPMIX(2);
2265 DEFINE_CAPMIX(3);
2266 DEFINE_CAPMIX_NOSRC(1);
2267 DEFINE_CAPMIX_NOSRC(2);
2268 DEFINE_CAPMIX_NOSRC(3);
2269
2270 /*
2271  * ALC880 5-stack model
2272  *
2273  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2274  *      Side = 0x02 (0xd)
2275  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2276  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2277  */
2278
2279 /* additional mixers to alc880_three_stack_mixer */
2280 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2281         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2282         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2283         { } /* end */
2284 };
2285
2286 /* channel source setting (6/8 channel selection for 5-stack) */
2287 /* 6ch mode */
2288 static struct hda_verb alc880_fivestack_ch6_init[] = {
2289         /* set line-in to input, mute it */
2290         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2291         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2292         { } /* end */
2293 };
2294
2295 /* 8ch mode */
2296 static struct hda_verb alc880_fivestack_ch8_init[] = {
2297         /* set line-in to output, unmute it */
2298         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2299         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2300         { } /* end */
2301 };
2302
2303 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2304         { 6, alc880_fivestack_ch6_init },
2305         { 8, alc880_fivestack_ch8_init },
2306 };
2307
2308
2309 /*
2310  * ALC880 6-stack model
2311  *
2312  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2313  *      Side = 0x05 (0x0f)
2314  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2315  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2316  */
2317
2318 static hda_nid_t alc880_6st_dac_nids[4] = {
2319         /* front, rear, clfe, rear_surr */
2320         0x02, 0x03, 0x04, 0x05
2321 };
2322
2323 static struct hda_input_mux alc880_6stack_capture_source = {
2324         .num_items = 4,
2325         .items = {
2326                 { "Mic", 0x0 },
2327                 { "Front Mic", 0x1 },
2328                 { "Line", 0x2 },
2329                 { "CD", 0x4 },
2330         },
2331 };
2332
2333 /* fixed 8-channels */
2334 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2335         { 8, NULL },
2336 };
2337
2338 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2339         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2340         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2341         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2342         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2343         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2344         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2345         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2346         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2347         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2348         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2349         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2350         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2351         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2352         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2353         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2354         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2355         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2356         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2357         {
2358                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2359                 .name = "Channel Mode",
2360                 .info = alc_ch_mode_info,
2361                 .get = alc_ch_mode_get,
2362                 .put = alc_ch_mode_put,
2363         },
2364         { } /* end */
2365 };
2366
2367
2368 /*
2369  * ALC880 W810 model
2370  *
2371  * W810 has rear IO for:
2372  * Front (DAC 02)
2373  * Surround (DAC 03)
2374  * Center/LFE (DAC 04)
2375  * Digital out (06)
2376  *
2377  * The system also has a pair of internal speakers, and a headphone jack.
2378  * These are both connected to Line2 on the codec, hence to DAC 02.
2379  *
2380  * There is a variable resistor to control the speaker or headphone
2381  * volume. This is a hardware-only device without a software API.
2382  *
2383  * Plugging headphones in will disable the internal speakers. This is
2384  * implemented in hardware, not via the driver using jack sense. In
2385  * a similar fashion, plugging into the rear socket marked "front" will
2386  * disable both the speakers and headphones.
2387  *
2388  * For input, there's a microphone jack, and an "audio in" jack.
2389  * These may not do anything useful with this driver yet, because I
2390  * haven't setup any initialization verbs for these yet...
2391  */
2392
2393 static hda_nid_t alc880_w810_dac_nids[3] = {
2394         /* front, rear/surround, clfe */
2395         0x02, 0x03, 0x04
2396 };
2397
2398 /* fixed 6 channels */
2399 static struct hda_channel_mode alc880_w810_modes[1] = {
2400         { 6, NULL }
2401 };
2402
2403 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2404 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2405         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2406         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2407         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2408         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2409         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2410         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2411         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2412         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2413         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2414         { } /* end */
2415 };
2416
2417
2418 /*
2419  * Z710V model
2420  *
2421  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2422  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2423  *                 Line = 0x1a
2424  */
2425
2426 static hda_nid_t alc880_z71v_dac_nids[1] = {
2427         0x02
2428 };
2429 #define ALC880_Z71V_HP_DAC      0x03
2430
2431 /* fixed 2 channels */
2432 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2433         { 2, NULL }
2434 };
2435
2436 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2437         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2438         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2439         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2440         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2441         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2442         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2443         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2444         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2445         { } /* end */
2446 };
2447
2448
2449 /*
2450  * ALC880 F1734 model
2451  *
2452  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2453  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2454  */
2455
2456 static hda_nid_t alc880_f1734_dac_nids[1] = {
2457         0x03
2458 };
2459 #define ALC880_F1734_HP_DAC     0x02
2460
2461 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2462         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2463         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2464         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2465         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2466         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2467         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2468         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2469         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2470         { } /* end */
2471 };
2472
2473 static struct hda_input_mux alc880_f1734_capture_source = {
2474         .num_items = 2,
2475         .items = {
2476                 { "Mic", 0x1 },
2477                 { "CD", 0x4 },
2478         },
2479 };
2480
2481
2482 /*
2483  * ALC880 ASUS model
2484  *
2485  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2486  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2487  *  Mic = 0x18, Line = 0x1a
2488  */
2489
2490 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2491 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2492
2493 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2494         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2495         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2496         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2497         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2498         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2499         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2500         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2501         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2502         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2503         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2504         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2505         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2506         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2507         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2508         {
2509                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2510                 .name = "Channel Mode",
2511                 .info = alc_ch_mode_info,
2512                 .get = alc_ch_mode_get,
2513                 .put = alc_ch_mode_put,
2514         },
2515         { } /* end */
2516 };
2517
2518 /*
2519  * ALC880 ASUS W1V model
2520  *
2521  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2522  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2523  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2524  */
2525
2526 /* additional mixers to alc880_asus_mixer */
2527 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2528         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2529         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2530         { } /* end */
2531 };
2532
2533 /* TCL S700 */
2534 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2535         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2536         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2537         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2538         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2539         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2540         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2541         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2542         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2543         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2544         { } /* end */
2545 };
2546
2547 /* Uniwill */
2548 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2549         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2550         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2551         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2552         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2553         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2554         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2555         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2556         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2557         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2558         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2559         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2560         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2561         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2562         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2563         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2564         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2565         {
2566                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2567                 .name = "Channel Mode",
2568                 .info = alc_ch_mode_info,
2569                 .get = alc_ch_mode_get,
2570                 .put = alc_ch_mode_put,
2571         },
2572         { } /* end */
2573 };
2574
2575 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2576         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2577         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2578         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2579         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2580         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2581         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2582         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2583         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2584         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2585         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2586         { } /* end */
2587 };
2588
2589 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2590         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2591         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2592         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2593         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2594         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2595         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2596         { } /* end */
2597 };
2598
2599 /*
2600  * virtual master controls
2601  */
2602
2603 /*
2604  * slave controls for virtual master
2605  */
2606 static const char *alc_slave_vols[] = {
2607         "Front Playback Volume",
2608         "Surround Playback Volume",
2609         "Center Playback Volume",
2610         "LFE Playback Volume",
2611         "Side Playback Volume",
2612         "Headphone Playback Volume",
2613         "Speaker Playback Volume",
2614         "Mono Playback Volume",
2615         "Line-Out Playback Volume",
2616         "PCM Playback Volume",
2617         NULL,
2618 };
2619
2620 static const char *alc_slave_sws[] = {
2621         "Front Playback Switch",
2622         "Surround Playback Switch",
2623         "Center Playback Switch",
2624         "LFE Playback Switch",
2625         "Side Playback Switch",
2626         "Headphone Playback Switch",
2627         "Speaker Playback Switch",
2628         "Mono Playback Switch",
2629         "IEC958 Playback Switch",
2630         "Line-Out Playback Switch",
2631         "PCM Playback Switch",
2632         NULL,
2633 };
2634
2635 /*
2636  * build control elements
2637  */
2638
2639 #define NID_MAPPING             (-1)
2640
2641 #define SUBDEV_SPEAKER_         (0 << 6)
2642 #define SUBDEV_HP_              (1 << 6)
2643 #define SUBDEV_LINE_            (2 << 6)
2644 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2645 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2646 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2647
2648 static void alc_free_kctls(struct hda_codec *codec);
2649
2650 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2651 /* additional beep mixers; the actual parameters are overwritten at build */
2652 static struct snd_kcontrol_new alc_beep_mixer[] = {
2653         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2654         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2655         { } /* end */
2656 };
2657 #endif
2658
2659 static int alc_build_controls(struct hda_codec *codec)
2660 {
2661         struct alc_spec *spec = codec->spec;
2662         struct snd_kcontrol *kctl = NULL;
2663         struct snd_kcontrol_new *knew;
2664         int i, j, err;
2665         unsigned int u;
2666         hda_nid_t nid;
2667
2668         for (i = 0; i < spec->num_mixers; i++) {
2669                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2670                 if (err < 0)
2671                         return err;
2672         }
2673         if (spec->cap_mixer) {
2674                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2675                 if (err < 0)
2676                         return err;
2677         }
2678         if (spec->multiout.dig_out_nid) {
2679                 err = snd_hda_create_spdif_out_ctls(codec,
2680                                                     spec->multiout.dig_out_nid);
2681                 if (err < 0)
2682                         return err;
2683                 if (!spec->no_analog) {
2684                         err = snd_hda_create_spdif_share_sw(codec,
2685                                                             &spec->multiout);
2686                         if (err < 0)
2687                                 return err;
2688                         spec->multiout.share_spdif = 1;
2689                 }
2690         }
2691         if (spec->dig_in_nid) {
2692                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2693                 if (err < 0)
2694                         return err;
2695         }
2696
2697 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2698         /* create beep controls if needed */
2699         if (spec->beep_amp) {
2700                 struct snd_kcontrol_new *knew;
2701                 for (knew = alc_beep_mixer; knew->name; knew++) {
2702                         struct snd_kcontrol *kctl;
2703                         kctl = snd_ctl_new1(knew, codec);
2704                         if (!kctl)
2705                                 return -ENOMEM;
2706                         kctl->private_value = spec->beep_amp;
2707                         err = snd_hda_ctl_add(codec, 0, kctl);
2708                         if (err < 0)
2709                                 return err;
2710                 }
2711         }
2712 #endif
2713
2714         /* if we have no master control, let's create it */
2715         if (!spec->no_analog &&
2716             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2717                 unsigned int vmaster_tlv[4];
2718                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2719                                         HDA_OUTPUT, vmaster_tlv);
2720                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2721                                           vmaster_tlv, alc_slave_vols);
2722                 if (err < 0)
2723                         return err;
2724         }
2725         if (!spec->no_analog &&
2726             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2727                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2728                                           NULL, alc_slave_sws);
2729                 if (err < 0)
2730                         return err;
2731         }
2732
2733         /* assign Capture Source enums to NID */
2734         if (spec->capsrc_nids || spec->adc_nids) {
2735                 kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2736                 if (!kctl)
2737                         kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2738                 for (i = 0; kctl && i < kctl->count; i++) {
2739                         hda_nid_t *nids = spec->capsrc_nids;
2740                         if (!nids)
2741                                 nids = spec->adc_nids;
2742                         err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2743                         if (err < 0)
2744                                 return err;
2745                 }
2746         }
2747         if (spec->cap_mixer) {
2748                 const char *kname = kctl ? kctl->id.name : NULL;
2749                 for (knew = spec->cap_mixer; knew->name; knew++) {
2750                         if (kname && strcmp(knew->name, kname) == 0)
2751                                 continue;
2752                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2753                         for (i = 0; kctl && i < kctl->count; i++) {
2754                                 err = snd_hda_add_nid(codec, kctl, i,
2755                                                       spec->adc_nids[i]);
2756                                 if (err < 0)
2757                                         return err;
2758                         }
2759                 }
2760         }
2761
2762         /* other nid->control mapping */
2763         for (i = 0; i < spec->num_mixers; i++) {
2764                 for (knew = spec->mixers[i]; knew->name; knew++) {
2765                         if (knew->iface != NID_MAPPING)
2766                                 continue;
2767                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2768                         if (kctl == NULL)
2769                                 continue;
2770                         u = knew->subdevice;
2771                         for (j = 0; j < 4; j++, u >>= 8) {
2772                                 nid = u & 0x3f;
2773                                 if (nid == 0)
2774                                         continue;
2775                                 switch (u & 0xc0) {
2776                                 case SUBDEV_SPEAKER_:
2777                                         nid = spec->autocfg.speaker_pins[nid];
2778                                         break;
2779                                 case SUBDEV_LINE_:
2780                                         nid = spec->autocfg.line_out_pins[nid];
2781                                         break;
2782                                 case SUBDEV_HP_:
2783                                         nid = spec->autocfg.hp_pins[nid];
2784                                         break;
2785                                 default:
2786                                         continue;
2787                                 }
2788                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2789                                 if (err < 0)
2790                                         return err;
2791                         }
2792                         u = knew->private_value;
2793                         for (j = 0; j < 4; j++, u >>= 8) {
2794                                 nid = u & 0xff;
2795                                 if (nid == 0)
2796                                         continue;
2797                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2798                                 if (err < 0)
2799                                         return err;
2800                         }
2801                 }
2802         }
2803
2804         alc_free_kctls(codec); /* no longer needed */
2805
2806         return 0;
2807 }
2808
2809
2810 /*
2811  * initialize the codec volumes, etc
2812  */
2813
2814 /*
2815  * generic initialization of ADC, input mixers and output mixers
2816  */
2817 static struct hda_verb alc880_volume_init_verbs[] = {
2818         /*
2819          * Unmute ADC0-2 and set the default input to mic-in
2820          */
2821         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2822         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2823         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2824         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2825         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2826         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2827
2828         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2829          * mixer widget
2830          * Note: PASD motherboards uses the Line In 2 as the input for front
2831          * panel mic (mic 2)
2832          */
2833         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2834         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2835         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2836         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2837         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2838         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2839         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2840         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2841
2842         /*
2843          * Set up output mixers (0x0c - 0x0f)
2844          */
2845         /* set vol=0 to output mixers */
2846         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2847         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2848         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2849         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2850         /* set up input amps for analog loopback */
2851         /* Amp Indices: DAC = 0, mixer = 1 */
2852         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2853         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2854         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2855         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2856         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2857         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2858         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2859         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2860
2861         { }
2862 };
2863
2864 /*
2865  * 3-stack pin configuration:
2866  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2867  */
2868 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2869         /*
2870          * preset connection lists of input pins
2871          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2872          */
2873         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2874         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2875         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2876
2877         /*
2878          * Set pin mode and muting
2879          */
2880         /* set front pin widgets 0x14 for output */
2881         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2882         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2883         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2884         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2885         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2886         /* Mic2 (as headphone out) for HP output */
2887         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2888         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2889         /* Line In pin widget for input */
2890         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2891         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2892         /* Line2 (as front mic) pin widget for input and vref at 80% */
2893         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2894         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2895         /* CD pin widget for input */
2896         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2897
2898         { }
2899 };
2900
2901 /*
2902  * 5-stack pin configuration:
2903  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2904  * line-in/side = 0x1a, f-mic = 0x1b
2905  */
2906 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2907         /*
2908          * preset connection lists of input pins
2909          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2910          */
2911         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2912         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2913
2914         /*
2915          * Set pin mode and muting
2916          */
2917         /* set pin widgets 0x14-0x17 for output */
2918         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2919         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2920         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2921         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2922         /* unmute pins for output (no gain on this amp) */
2923         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2924         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2925         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2926         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2927
2928         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2929         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2930         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2931         /* Mic2 (as headphone out) for HP output */
2932         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2933         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2934         /* Line In pin widget for input */
2935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2936         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2937         /* Line2 (as front mic) pin widget for input and vref at 80% */
2938         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2939         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2940         /* CD pin widget for input */
2941         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2942
2943         { }
2944 };
2945
2946 /*
2947  * W810 pin configuration:
2948  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2949  */
2950 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2951         /* hphone/speaker input selector: front DAC */
2952         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2953
2954         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2955         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2956         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2957         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2958         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2959         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2960
2961         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2962         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2963
2964         { }
2965 };
2966
2967 /*
2968  * Z71V pin configuration:
2969  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2970  */
2971 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2972         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2973         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2974         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2975         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2976
2977         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2978         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2979         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2980         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2981
2982         { }
2983 };
2984
2985 /*
2986  * 6-stack pin configuration:
2987  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2988  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2989  */
2990 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2991         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2992
2993         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2994         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2995         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2996         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2997         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2998         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2999         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3000         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3001
3002         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3003         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3004         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3005         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3006         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3007         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3008         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3009         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3010         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3011
3012         { }
3013 };
3014
3015 /*
3016  * Uniwill pin configuration:
3017  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
3018  * line = 0x1a
3019  */
3020 static struct hda_verb alc880_uniwill_init_verbs[] = {
3021         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3022
3023         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3024         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3025         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3026         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3027         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3028         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3030         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3031         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3032         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3033         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3034         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3035         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3036         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3037
3038         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3039         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3040         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3041         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3042         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3043         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3044         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
3045         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
3046         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3047
3048         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3049         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
3050
3051         { }
3052 };
3053
3054 /*
3055 * Uniwill P53
3056 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
3057  */
3058 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
3059         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3060
3061         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3062         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3063         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3064         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3066         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3067         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3068         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3069         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3070         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3071         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
3072         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
3073
3074         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3075         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3076         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3077         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3078         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3079         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3080
3081         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3082         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
3083
3084         { }
3085 };
3086
3087 static struct hda_verb alc880_beep_init_verbs[] = {
3088         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
3089         { }
3090 };
3091
3092 /* auto-toggle front mic */
3093 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
3094 {
3095         unsigned int present;
3096         unsigned char bits;
3097
3098         present = snd_hda_jack_detect(codec, 0x18);
3099         bits = present ? HDA_AMP_MUTE : 0;
3100         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
3101 }
3102
3103 static void alc880_uniwill_setup(struct hda_codec *codec)
3104 {
3105         struct alc_spec *spec = codec->spec;
3106
3107         spec->autocfg.hp_pins[0] = 0x14;
3108         spec->autocfg.speaker_pins[0] = 0x15;
3109         spec->autocfg.speaker_pins[0] = 0x16;
3110 }
3111
3112 static void alc880_uniwill_init_hook(struct hda_codec *codec)
3113 {
3114         alc_automute_amp(codec);
3115         alc880_uniwill_mic_automute(codec);
3116 }
3117
3118 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
3119                                        unsigned int res)
3120 {
3121         /* Looks like the unsol event is incompatible with the standard
3122          * definition.  4bit tag is placed at 28 bit!
3123          */
3124         switch (res >> 28) {
3125         case ALC880_MIC_EVENT:
3126                 alc880_uniwill_mic_automute(codec);
3127                 break;
3128         default:
3129                 alc_automute_amp_unsol_event(codec, res);
3130                 break;
3131         }
3132 }
3133
3134 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
3135 {
3136         struct alc_spec *spec = codec->spec;
3137
3138         spec->autocfg.hp_pins[0] = 0x14;
3139         spec->autocfg.speaker_pins[0] = 0x15;
3140 }
3141
3142 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
3143 {
3144         unsigned int present;
3145
3146         present = snd_hda_codec_read(codec, 0x21, 0,
3147                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
3148         present &= HDA_AMP_VOLMASK;
3149         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
3150                                  HDA_AMP_VOLMASK, present);
3151         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
3152                                  HDA_AMP_VOLMASK, present);
3153 }
3154
3155 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
3156                                            unsigned int res)
3157 {
3158         /* Looks like the unsol event is incompatible with the standard
3159          * definition.  4bit tag is placed at 28 bit!
3160          */
3161         if ((res >> 28) == ALC880_DCVOL_EVENT)
3162                 alc880_uniwill_p53_dcvol_automute(codec);
3163         else
3164                 alc_automute_amp_unsol_event(codec, res);
3165 }
3166
3167 /*
3168  * F1734 pin configuration:
3169  * HP = 0x14, speaker-out = 0x15, mic = 0x18
3170  */
3171 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
3172         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
3173         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3174         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3175         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3176         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3177
3178         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3179         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3180         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3181         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3182
3183         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3184         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3185         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
3186         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3187         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3188         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3189         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3190         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3191         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3192
3193         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3194         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3195
3196         { }
3197 };
3198
3199 /*
3200  * ASUS pin configuration:
3201  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3202  */
3203 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3204         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3205         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3206         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3207         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3208
3209         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3210         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3211         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3212         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3213         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3214         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3215         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3216         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3217
3218         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3219         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3220         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3221         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3222         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3223         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3224         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3225         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3226         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3227
3228         { }
3229 };
3230
3231 /* Enable GPIO mask and set output */
3232 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3233 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3234 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3235
3236 /* Clevo m520g init */
3237 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3238         /* headphone output */
3239         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3240         /* line-out */
3241         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3242         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3243         /* Line-in */
3244         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3245         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3246         /* CD */
3247         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3248         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3249         /* Mic1 (rear panel) */
3250         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3251         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3252         /* Mic2 (front panel) */
3253         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3254         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3255         /* headphone */
3256         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3257         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3258         /* change to EAPD mode */
3259         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3260         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3261
3262         { }
3263 };
3264
3265 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3266         /* change to EAPD mode */
3267         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3268         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3269
3270         /* Headphone output */
3271         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3272         /* Front output*/
3273         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3274         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3275
3276         /* Line In pin widget for input */
3277         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3278         /* CD pin widget for input */
3279         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3280         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3281         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3282
3283         /* change to EAPD mode */
3284         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3285         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3286
3287         { }
3288 };
3289
3290 /*
3291  * LG m1 express dual
3292  *
3293  * Pin assignment:
3294  *   Rear Line-In/Out (blue): 0x14
3295  *   Build-in Mic-In: 0x15
3296  *   Speaker-out: 0x17
3297  *   HP-Out (green): 0x1b
3298  *   Mic-In/Out (red): 0x19
3299  *   SPDIF-Out: 0x1e
3300  */
3301
3302 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3303 static hda_nid_t alc880_lg_dac_nids[3] = {
3304         0x05, 0x02, 0x03
3305 };
3306
3307 /* seems analog CD is not working */
3308 static struct hda_input_mux alc880_lg_capture_source = {
3309         .num_items = 3,
3310         .items = {
3311                 { "Mic", 0x1 },
3312                 { "Line", 0x5 },
3313                 { "Internal Mic", 0x6 },
3314         },
3315 };
3316
3317 /* 2,4,6 channel modes */
3318 static struct hda_verb alc880_lg_ch2_init[] = {
3319         /* set line-in and mic-in to input */
3320         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3321         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3322         { }
3323 };
3324
3325 static struct hda_verb alc880_lg_ch4_init[] = {
3326         /* set line-in to out and mic-in to input */
3327         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3328         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3329         { }
3330 };
3331
3332 static struct hda_verb alc880_lg_ch6_init[] = {
3333         /* set line-in and mic-in to output */
3334         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3335         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3336         { }
3337 };
3338
3339 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3340         { 2, alc880_lg_ch2_init },
3341         { 4, alc880_lg_ch4_init },
3342         { 6, alc880_lg_ch6_init },
3343 };
3344
3345 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3346         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3347         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3348         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3349         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3350         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3351         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3352         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3353         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3354         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3355         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3356         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3357         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3358         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3359         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3360         {
3361                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3362                 .name = "Channel Mode",
3363                 .info = alc_ch_mode_info,
3364                 .get = alc_ch_mode_get,
3365                 .put = alc_ch_mode_put,
3366         },
3367         { } /* end */
3368 };
3369
3370 static struct hda_verb alc880_lg_init_verbs[] = {
3371         /* set capture source to mic-in */
3372         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3373         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3374         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3375         /* mute all amp mixer inputs */
3376         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3377         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3378         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3379         /* line-in to input */
3380         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3381         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3382         /* built-in mic */
3383         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3384         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3385         /* speaker-out */
3386         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3387         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3388         /* mic-in to input */
3389         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3390         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3391         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3392         /* HP-out */
3393         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3394         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3395         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3396         /* jack sense */
3397         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3398         { }
3399 };
3400
3401 /* toggle speaker-output according to the hp-jack state */
3402 static void alc880_lg_setup(struct hda_codec *codec)
3403 {
3404         struct alc_spec *spec = codec->spec;
3405
3406         spec->autocfg.hp_pins[0] = 0x1b;
3407         spec->autocfg.speaker_pins[0] = 0x17;
3408 }
3409
3410 /*
3411  * LG LW20
3412  *
3413  * Pin assignment:
3414  *   Speaker-out: 0x14
3415  *   Mic-In: 0x18
3416  *   Built-in Mic-In: 0x19
3417  *   Line-In: 0x1b
3418  *   HP-Out: 0x1a
3419  *   SPDIF-Out: 0x1e
3420  */
3421
3422 static struct hda_input_mux alc880_lg_lw_capture_source = {
3423         .num_items = 3,
3424         .items = {
3425                 { "Mic", 0x0 },
3426                 { "Internal Mic", 0x1 },
3427                 { "Line In", 0x2 },
3428         },
3429 };
3430
3431 #define alc880_lg_lw_modes alc880_threestack_modes
3432
3433 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3434         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3435         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3436         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3437         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3438         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3439         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3440         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3441         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3442         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3443         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3444         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3445         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3446         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3447         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3448         {
3449                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3450                 .name = "Channel Mode",
3451                 .info = alc_ch_mode_info,
3452                 .get = alc_ch_mode_get,
3453                 .put = alc_ch_mode_put,
3454         },
3455         { } /* end */
3456 };
3457
3458 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3459         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3460         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3461         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3462
3463         /* set capture source to mic-in */
3464         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3465         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3466         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3467         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3468         /* speaker-out */
3469         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3470         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3471         /* HP-out */
3472         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3473         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3474         /* mic-in to input */
3475         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3476         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3477         /* built-in mic */
3478         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3479         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3480         /* jack sense */
3481         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3482         { }
3483 };
3484
3485 /* toggle speaker-output according to the hp-jack state */
3486 static void alc880_lg_lw_setup(struct hda_codec *codec)
3487 {
3488         struct alc_spec *spec = codec->spec;
3489
3490         spec->autocfg.hp_pins[0] = 0x1b;
3491         spec->autocfg.speaker_pins[0] = 0x14;
3492 }
3493
3494 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3495         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3496         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3497         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3498         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3499         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3500         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3501         { } /* end */
3502 };
3503
3504 static struct hda_input_mux alc880_medion_rim_capture_source = {
3505         .num_items = 2,
3506         .items = {
3507                 { "Mic", 0x0 },
3508                 { "Internal Mic", 0x1 },
3509         },
3510 };
3511
3512 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3513         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3514
3515         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3516         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3517
3518         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3519         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3520         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3521         /* Mic2 (as headphone out) for HP output */
3522         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3523         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3524         /* Internal Speaker */
3525         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3526         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3527
3528         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3529         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3530
3531         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3532         { }
3533 };
3534
3535 /* toggle speaker-output according to the hp-jack state */
3536 static void alc880_medion_rim_automute(struct hda_codec *codec)
3537 {
3538         struct alc_spec *spec = codec->spec;
3539         alc_automute_amp(codec);
3540         /* toggle EAPD */
3541         if (spec->jack_present)
3542                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3543         else
3544                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3545 }
3546
3547 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3548                                           unsigned int res)
3549 {
3550         /* Looks like the unsol event is incompatible with the standard
3551          * definition.  4bit tag is placed at 28 bit!
3552          */
3553         if ((res >> 28) == ALC880_HP_EVENT)
3554                 alc880_medion_rim_automute(codec);
3555 }
3556
3557 static void alc880_medion_rim_setup(struct hda_codec *codec)
3558 {
3559         struct alc_spec *spec = codec->spec;
3560
3561         spec->autocfg.hp_pins[0] = 0x14;
3562         spec->autocfg.speaker_pins[0] = 0x1b;
3563 }
3564
3565 #ifdef CONFIG_SND_HDA_POWER_SAVE
3566 static struct hda_amp_list alc880_loopbacks[] = {
3567         { 0x0b, HDA_INPUT, 0 },
3568         { 0x0b, HDA_INPUT, 1 },
3569         { 0x0b, HDA_INPUT, 2 },
3570         { 0x0b, HDA_INPUT, 3 },
3571         { 0x0b, HDA_INPUT, 4 },
3572         { } /* end */
3573 };
3574
3575 static struct hda_amp_list alc880_lg_loopbacks[] = {
3576         { 0x0b, HDA_INPUT, 1 },
3577         { 0x0b, HDA_INPUT, 6 },
3578         { 0x0b, HDA_INPUT, 7 },
3579         { } /* end */
3580 };
3581 #endif
3582
3583 /*
3584  * Common callbacks
3585  */
3586
3587 static int alc_init(struct hda_codec *codec)
3588 {
3589         struct alc_spec *spec = codec->spec;
3590         unsigned int i;
3591
3592         alc_fix_pll(codec);
3593         alc_auto_init_amp(codec, spec->init_amp);
3594
3595         for (i = 0; i < spec->num_init_verbs; i++)
3596                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3597
3598         if (spec->init_hook)
3599                 spec->init_hook(codec);
3600
3601 #ifdef CONFIG_SND_HDA_POWER_SAVE
3602         if (codec->patch_ops.check_power_status)
3603                 codec->patch_ops.check_power_status(codec, 0x01);
3604 #endif
3605         return 0;
3606 }
3607
3608 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3609 {
3610         struct alc_spec *spec = codec->spec;
3611
3612         if (spec->unsol_event)
3613                 spec->unsol_event(codec, res);
3614 }
3615
3616 #ifdef CONFIG_SND_HDA_POWER_SAVE
3617 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3618 {
3619         struct alc_spec *spec = codec->spec;
3620         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3621 }
3622 #endif
3623
3624 /*
3625  * Analog playback callbacks
3626  */
3627 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3628                                     struct hda_codec *codec,
3629                                     struct snd_pcm_substream *substream)
3630 {
3631         struct alc_spec *spec = codec->spec;
3632         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3633                                              hinfo);
3634 }
3635
3636 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3637                                        struct hda_codec *codec,
3638                                        unsigned int stream_tag,
3639                                        unsigned int format,
3640                                        struct snd_pcm_substream *substream)
3641 {
3642         struct alc_spec *spec = codec->spec;
3643         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3644                                                 stream_tag, format, substream);
3645 }
3646
3647 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3648                                        struct hda_codec *codec,
3649                                        struct snd_pcm_substream *substream)
3650 {
3651         struct alc_spec *spec = codec->spec;
3652         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3653 }
3654
3655 /*
3656  * Digital out
3657  */
3658 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3659                                         struct hda_codec *codec,
3660                                         struct snd_pcm_substream *substream)
3661 {
3662         struct alc_spec *spec = codec->spec;
3663         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3664 }
3665
3666 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3667                                            struct hda_codec *codec,
3668                                            unsigned int stream_tag,
3669                                            unsigned int format,
3670                                            struct snd_pcm_substream *substream)
3671 {
3672         struct alc_spec *spec = codec->spec;
3673         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3674                                              stream_tag, format, substream);
3675 }
3676
3677 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3678                                            struct hda_codec *codec,
3679                                            struct snd_pcm_substream *substream)
3680 {
3681         struct alc_spec *spec = codec->spec;
3682         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3683 }
3684
3685 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3686                                          struct hda_codec *codec,
3687                                          struct snd_pcm_substream *substream)
3688 {
3689         struct alc_spec *spec = codec->spec;
3690         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3691 }
3692
3693 /*
3694  * Analog capture
3695  */
3696 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3697                                       struct hda_codec *codec,
3698                                       unsigned int stream_tag,
3699                                       unsigned int format,
3700                                       struct snd_pcm_substream *substream)
3701 {
3702         struct alc_spec *spec = codec->spec;
3703
3704         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3705                                    stream_tag, 0, format);
3706         return 0;
3707 }
3708
3709 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3710                                       struct hda_codec *codec,
3711                                       struct snd_pcm_substream *substream)
3712 {
3713         struct alc_spec *spec = codec->spec;
3714
3715         snd_hda_codec_cleanup_stream(codec,
3716                                      spec->adc_nids[substream->number + 1]);
3717         return 0;
3718 }
3719
3720 /* analog capture with dynamic dual-adc changes */
3721 static int dualmic_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3722                                        struct hda_codec *codec,
3723                                        unsigned int stream_tag,
3724                                        unsigned int format,
3725                                        struct snd_pcm_substream *substream)
3726 {
3727         struct alc_spec *spec = codec->spec;
3728         spec->cur_adc = spec->adc_nids[spec->cur_adc_idx];
3729         spec->cur_adc_stream_tag = stream_tag;
3730         spec->cur_adc_format = format;
3731         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
3732         return 0;
3733 }
3734
3735 static int dualmic_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3736                                        struct hda_codec *codec,
3737                                        struct snd_pcm_substream *substream)
3738 {
3739         struct alc_spec *spec = codec->spec;
3740         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
3741         spec->cur_adc = 0;
3742         return 0;
3743 }
3744
3745 static struct hda_pcm_stream dualmic_pcm_analog_capture = {
3746         .substreams = 1,
3747         .channels_min = 2,
3748         .channels_max = 2,
3749         .nid = 0, /* fill later */
3750         .ops = {
3751                 .prepare = dualmic_capture_pcm_prepare,
3752                 .cleanup = dualmic_capture_pcm_cleanup
3753         },
3754 };
3755
3756 /*
3757  */
3758 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3759         .substreams = 1,
3760         .channels_min = 2,
3761         .channels_max = 8,
3762         /* NID is set in alc_build_pcms */
3763         .ops = {
3764                 .open = alc880_playback_pcm_open,
3765                 .prepare = alc880_playback_pcm_prepare,
3766                 .cleanup = alc880_playback_pcm_cleanup
3767         },
3768 };
3769
3770 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3771         .substreams = 1,
3772         .channels_min = 2,
3773         .channels_max = 2,
3774         /* NID is set in alc_build_pcms */
3775 };
3776
3777 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3778         .substreams = 1,
3779         .channels_min = 2,
3780         .channels_max = 2,
3781         /* NID is set in alc_build_pcms */
3782 };
3783
3784 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3785         .substreams = 2, /* can be overridden */
3786         .channels_min = 2,
3787         .channels_max = 2,
3788         /* NID is set in alc_build_pcms */
3789         .ops = {
3790                 .prepare = alc880_alt_capture_pcm_prepare,
3791                 .cleanup = alc880_alt_capture_pcm_cleanup
3792         },
3793 };
3794
3795 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3796         .substreams = 1,
3797         .channels_min = 2,
3798         .channels_max = 2,
3799         /* NID is set in alc_build_pcms */
3800         .ops = {
3801                 .open = alc880_dig_playback_pcm_open,
3802                 .close = alc880_dig_playback_pcm_close,
3803                 .prepare = alc880_dig_playback_pcm_prepare,
3804                 .cleanup = alc880_dig_playback_pcm_cleanup
3805         },
3806 };
3807
3808 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3809         .substreams = 1,
3810         .channels_min = 2,
3811         .channels_max = 2,
3812         /* NID is set in alc_build_pcms */
3813 };
3814
3815 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3816 static struct hda_pcm_stream alc_pcm_null_stream = {
3817         .substreams = 0,
3818         .channels_min = 0,
3819         .channels_max = 0,
3820 };
3821
3822 static int alc_build_pcms(struct hda_codec *codec)
3823 {
3824         struct alc_spec *spec = codec->spec;
3825         struct hda_pcm *info = spec->pcm_rec;
3826         int i;
3827
3828         codec->num_pcms = 1;
3829         codec->pcm_info = info;
3830
3831         if (spec->no_analog)
3832                 goto skip_analog;
3833
3834         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3835                  "%s Analog", codec->chip_name);
3836         info->name = spec->stream_name_analog;
3837
3838         if (spec->stream_analog_playback) {
3839                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3840                         return -EINVAL;
3841                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3842                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3843         }
3844         if (spec->stream_analog_capture) {
3845                 if (snd_BUG_ON(!spec->adc_nids))
3846                         return -EINVAL;
3847                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3848                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3849         }
3850
3851         if (spec->channel_mode) {
3852                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3853                 for (i = 0; i < spec->num_channel_mode; i++) {
3854                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3855                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3856                         }
3857                 }
3858         }
3859
3860  skip_analog:
3861         /* SPDIF for stream index #1 */
3862         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3863                 snprintf(spec->stream_name_digital,
3864                          sizeof(spec->stream_name_digital),
3865                          "%s Digital", codec->chip_name);
3866                 codec->num_pcms = 2;
3867                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3868                 info = spec->pcm_rec + 1;
3869                 info->name = spec->stream_name_digital;
3870                 if (spec->dig_out_type)
3871                         info->pcm_type = spec->dig_out_type;
3872                 else
3873                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3874                 if (spec->multiout.dig_out_nid &&
3875                     spec->stream_digital_playback) {
3876                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3877                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3878                 }
3879                 if (spec->dig_in_nid &&
3880                     spec->stream_digital_capture) {
3881                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3882                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3883                 }
3884                 /* FIXME: do we need this for all Realtek codec models? */
3885                 codec->spdif_status_reset = 1;
3886         }
3887
3888         if (spec->no_analog)
3889                 return 0;
3890
3891         /* If the use of more than one ADC is requested for the current
3892          * model, configure a second analog capture-only PCM.
3893          */
3894         /* Additional Analaog capture for index #2 */
3895         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3896             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3897                 codec->num_pcms = 3;
3898                 info = spec->pcm_rec + 2;
3899                 info->name = spec->stream_name_analog;
3900                 if (spec->alt_dac_nid) {
3901                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3902                                 *spec->stream_analog_alt_playback;
3903                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3904                                 spec->alt_dac_nid;
3905                 } else {
3906                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3907                                 alc_pcm_null_stream;
3908                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3909                 }
3910                 if (spec->num_adc_nids > 1) {
3911                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3912                                 *spec->stream_analog_alt_capture;
3913                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3914                                 spec->adc_nids[1];
3915                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3916                                 spec->num_adc_nids - 1;
3917                 } else {
3918                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3919                                 alc_pcm_null_stream;
3920                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3921                 }
3922         }
3923
3924         return 0;
3925 }
3926
3927 static inline void alc_shutup(struct hda_codec *codec)
3928 {
3929         snd_hda_shutup_pins(codec);
3930 }
3931
3932 static void alc_free_kctls(struct hda_codec *codec)
3933 {
3934         struct alc_spec *spec = codec->spec;
3935
3936         if (spec->kctls.list) {
3937                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3938                 int i;
3939                 for (i = 0; i < spec->kctls.used; i++)
3940                         kfree(kctl[i].name);
3941         }
3942         snd_array_free(&spec->kctls);
3943 }
3944
3945 static void alc_free(struct hda_codec *codec)
3946 {
3947         struct alc_spec *spec = codec->spec;
3948
3949         if (!spec)
3950                 return;
3951
3952         alc_shutup(codec);
3953         alc_free_kctls(codec);
3954         kfree(spec);
3955         snd_hda_detach_beep_device(codec);
3956 }
3957
3958 #ifdef CONFIG_SND_HDA_POWER_SAVE
3959 static void alc_power_eapd(struct hda_codec *codec)
3960 {
3961         /* We currently only handle front, HP */
3962         switch (codec->vendor_id) {
3963         case 0x10ec0260:
3964                 set_eapd(codec, 0x0f, 0);
3965                 set_eapd(codec, 0x10, 0);
3966                 break;
3967         case 0x10ec0262:
3968         case 0x10ec0267:
3969         case 0x10ec0268:
3970         case 0x10ec0269:
3971         case 0x10ec0270:
3972         case 0x10ec0272:
3973         case 0x10ec0660:
3974         case 0x10ec0662:
3975         case 0x10ec0663:
3976         case 0x10ec0862:
3977         case 0x10ec0889:
3978                 set_eapd(codec, 0x14, 0);
3979                 set_eapd(codec, 0x15, 0);
3980                 break;
3981         }
3982 }
3983
3984 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3985 {
3986         struct alc_spec *spec = codec->spec;
3987         alc_shutup(codec);
3988         if (spec && spec->power_hook)
3989                 spec->power_hook(codec);
3990         return 0;
3991 }
3992 #endif
3993
3994 #ifdef SND_HDA_NEEDS_RESUME
3995 static int alc_resume(struct hda_codec *codec)
3996 {
3997         codec->patch_ops.init(codec);
3998         snd_hda_codec_resume_amp(codec);
3999         snd_hda_codec_resume_cache(codec);
4000 #ifdef CONFIG_SND_HDA_POWER_SAVE
4001         if (codec->patch_ops.check_power_status)
4002                 codec->patch_ops.check_power_status(codec, 0x01);
4003 #endif
4004         return 0;
4005 }
4006 #endif
4007
4008 /*
4009  */
4010 static struct hda_codec_ops alc_patch_ops = {
4011         .build_controls = alc_build_controls,
4012         .build_pcms = alc_build_pcms,
4013         .init = alc_init,
4014         .free = alc_free,
4015         .unsol_event = alc_unsol_event,
4016 #ifdef SND_HDA_NEEDS_RESUME
4017         .resume = alc_resume,
4018 #endif
4019 #ifdef CONFIG_SND_HDA_POWER_SAVE
4020         .suspend = alc_suspend,
4021         .check_power_status = alc_check_power_status,
4022 #endif
4023         .reboot_notify = alc_shutup,
4024 };
4025
4026 /* replace the codec chip_name with the given string */
4027 static int alc_codec_rename(struct hda_codec *codec, const char *name)
4028 {
4029         kfree(codec->chip_name);
4030         codec->chip_name = kstrdup(name, GFP_KERNEL);
4031         if (!codec->chip_name) {
4032                 alc_free(codec);
4033                 return -ENOMEM;
4034         }
4035         return 0;
4036 }
4037
4038 /*
4039  * Test configuration for debugging
4040  *
4041  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
4042  * enum controls.
4043  */
4044 #ifdef CONFIG_SND_DEBUG
4045 static hda_nid_t alc880_test_dac_nids[4] = {
4046         0x02, 0x03, 0x04, 0x05
4047 };
4048
4049 static struct hda_input_mux alc880_test_capture_source = {
4050         .num_items = 7,
4051         .items = {
4052                 { "In-1", 0x0 },
4053                 { "In-2", 0x1 },
4054                 { "In-3", 0x2 },
4055                 { "In-4", 0x3 },
4056                 { "CD", 0x4 },
4057                 { "Front", 0x5 },
4058                 { "Surround", 0x6 },
4059         },
4060 };
4061
4062 static struct hda_channel_mode alc880_test_modes[4] = {
4063         { 2, NULL },
4064         { 4, NULL },
4065         { 6, NULL },
4066         { 8, NULL },
4067 };
4068
4069 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
4070                                  struct snd_ctl_elem_info *uinfo)
4071 {
4072         static char *texts[] = {
4073                 "N/A", "Line Out", "HP Out",
4074                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
4075         };
4076         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4077         uinfo->count = 1;
4078         uinfo->value.enumerated.items = 8;
4079         if (uinfo->value.enumerated.item >= 8)
4080                 uinfo->value.enumerated.item = 7;
4081         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4082         return 0;
4083 }
4084
4085 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
4086                                 struct snd_ctl_elem_value *ucontrol)
4087 {
4088         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4089         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4090         unsigned int pin_ctl, item = 0;
4091
4092         pin_ctl = snd_hda_codec_read(codec, nid, 0,
4093                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4094         if (pin_ctl & AC_PINCTL_OUT_EN) {
4095                 if (pin_ctl & AC_PINCTL_HP_EN)
4096                         item = 2;
4097                 else
4098                         item = 1;
4099         } else if (pin_ctl & AC_PINCTL_IN_EN) {
4100                 switch (pin_ctl & AC_PINCTL_VREFEN) {
4101                 case AC_PINCTL_VREF_HIZ: item = 3; break;
4102                 case AC_PINCTL_VREF_50:  item = 4; break;
4103                 case AC_PINCTL_VREF_GRD: item = 5; break;
4104                 case AC_PINCTL_VREF_80:  item = 6; break;
4105                 case AC_PINCTL_VREF_100: item = 7; break;
4106                 }
4107         }
4108         ucontrol->value.enumerated.item[0] = item;
4109         return 0;
4110 }
4111
4112 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
4113                                 struct snd_ctl_elem_value *ucontrol)
4114 {
4115         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4116         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4117         static unsigned int ctls[] = {
4118                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
4119                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
4120                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
4121                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
4122                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
4123                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
4124         };
4125         unsigned int old_ctl, new_ctl;
4126
4127         old_ctl = snd_hda_codec_read(codec, nid, 0,
4128                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
4129         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
4130         if (old_ctl != new_ctl) {
4131                 int val;
4132                 snd_hda_codec_write_cache(codec, nid, 0,
4133                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
4134                                           new_ctl);
4135                 val = ucontrol->value.enumerated.item[0] >= 3 ?
4136                         HDA_AMP_MUTE : 0;
4137                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
4138                                          HDA_AMP_MUTE, val);
4139                 return 1;
4140         }
4141         return 0;
4142 }
4143
4144 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
4145                                  struct snd_ctl_elem_info *uinfo)
4146 {
4147         static char *texts[] = {
4148                 "Front", "Surround", "CLFE", "Side"
4149         };
4150         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
4151         uinfo->count = 1;
4152         uinfo->value.enumerated.items = 4;
4153         if (uinfo->value.enumerated.item >= 4)
4154                 uinfo->value.enumerated.item = 3;
4155         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
4156         return 0;
4157 }
4158
4159 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
4160                                 struct snd_ctl_elem_value *ucontrol)
4161 {
4162         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4163         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4164         unsigned int sel;
4165
4166         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
4167         ucontrol->value.enumerated.item[0] = sel & 3;
4168         return 0;
4169 }
4170
4171 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
4172                                 struct snd_ctl_elem_value *ucontrol)
4173 {
4174         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
4175         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
4176         unsigned int sel;
4177
4178         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
4179         if (ucontrol->value.enumerated.item[0] != sel) {
4180                 sel = ucontrol->value.enumerated.item[0] & 3;
4181                 snd_hda_codec_write_cache(codec, nid, 0,
4182                                           AC_VERB_SET_CONNECT_SEL, sel);
4183                 return 1;
4184         }
4185         return 0;
4186 }
4187
4188 #define PIN_CTL_TEST(xname,nid) {                       \
4189                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4190                         .name = xname,                 \
4191                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4192                         .info = alc_test_pin_ctl_info, \
4193                         .get = alc_test_pin_ctl_get,   \
4194                         .put = alc_test_pin_ctl_put,   \
4195                         .private_value = nid           \
4196                         }
4197
4198 #define PIN_SRC_TEST(xname,nid) {                       \
4199                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
4200                         .name = xname,                 \
4201                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
4202                         .info = alc_test_pin_src_info, \
4203                         .get = alc_test_pin_src_get,   \
4204                         .put = alc_test_pin_src_put,   \
4205                         .private_value = nid           \
4206                         }
4207
4208 static struct snd_kcontrol_new alc880_test_mixer[] = {
4209         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
4210         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
4211         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
4212         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
4213         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
4214         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
4215         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
4216         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
4217         PIN_CTL_TEST("Front Pin Mode", 0x14),
4218         PIN_CTL_TEST("Surround Pin Mode", 0x15),
4219         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
4220         PIN_CTL_TEST("Side Pin Mode", 0x17),
4221         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
4222         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
4223         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
4224         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
4225         PIN_SRC_TEST("In-1 Pin Source", 0x18),
4226         PIN_SRC_TEST("In-2 Pin Source", 0x19),
4227         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
4228         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
4229         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
4230         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
4231         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
4232         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
4233         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
4234         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
4235         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
4236         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
4237         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
4238         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
4239         {
4240                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
4241                 .name = "Channel Mode",
4242                 .info = alc_ch_mode_info,
4243                 .get = alc_ch_mode_get,
4244                 .put = alc_ch_mode_put,
4245         },
4246         { } /* end */
4247 };
4248
4249 static struct hda_verb alc880_test_init_verbs[] = {
4250         /* Unmute inputs of 0x0c - 0x0f */
4251         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4252         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4253         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4254         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4255         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4256         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4257         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4258         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4259         /* Vol output for 0x0c-0x0f */
4260         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4261         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4262         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4263         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4264         /* Set output pins 0x14-0x17 */
4265         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4266         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4267         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4268         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4269         /* Unmute output pins 0x14-0x17 */
4270         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4271         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4272         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4273         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4274         /* Set input pins 0x18-0x1c */
4275         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4276         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4277         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4278         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4279         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4280         /* Mute input pins 0x18-0x1b */
4281         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4282         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4283         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4284         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4285         /* ADC set up */
4286         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4287         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4288         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4289         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4290         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4291         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4292         /* Analog input/passthru */
4293         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4294         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4295         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4296         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4297         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4298         { }
4299 };
4300 #endif
4301
4302 /*
4303  */
4304
4305 static const char *alc880_models[ALC880_MODEL_LAST] = {
4306         [ALC880_3ST]            = "3stack",
4307         [ALC880_TCL_S700]       = "tcl",
4308         [ALC880_3ST_DIG]        = "3stack-digout",
4309         [ALC880_CLEVO]          = "clevo",
4310         [ALC880_5ST]            = "5stack",
4311         [ALC880_5ST_DIG]        = "5stack-digout",
4312         [ALC880_W810]           = "w810",
4313         [ALC880_Z71V]           = "z71v",
4314         [ALC880_6ST]            = "6stack",
4315         [ALC880_6ST_DIG]        = "6stack-digout",
4316         [ALC880_ASUS]           = "asus",
4317         [ALC880_ASUS_W1V]       = "asus-w1v",
4318         [ALC880_ASUS_DIG]       = "asus-dig",
4319         [ALC880_ASUS_DIG2]      = "asus-dig2",
4320         [ALC880_UNIWILL_DIG]    = "uniwill",
4321         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4322         [ALC880_FUJITSU]        = "fujitsu",
4323         [ALC880_F1734]          = "F1734",
4324         [ALC880_LG]             = "lg",
4325         [ALC880_LG_LW]          = "lg-lw",
4326         [ALC880_MEDION_RIM]     = "medion",
4327 #ifdef CONFIG_SND_DEBUG
4328         [ALC880_TEST]           = "test",
4329 #endif
4330         [ALC880_AUTO]           = "auto",
4331 };
4332
4333 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4334         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4335         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4336         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4337         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4338         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4339         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4340         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4341         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4342         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4343         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4344         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4345         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4346         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4347         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4348         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4349         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4350         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4351         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4352         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4353         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4354         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4355         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4356         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4357         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4358         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4359         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4360         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4361         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4362         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4363         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4364         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4365         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4366         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4367         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4368         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4369         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4370         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4371         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4372         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4373         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4374         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4375         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4376         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4377         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4378         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4379         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4380         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4381         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4382         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4383         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC AMILO Xi 1526", ALC880_F1734),
4384         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4385         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4386         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4387         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4388         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4389         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4390         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4391         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4392         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4393         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4394         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4395         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4396         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4397         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4398         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4399         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4400         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4401         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4402         /* default Intel */
4403         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4404         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4405         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4406         {}
4407 };
4408
4409 /*
4410  * ALC880 codec presets
4411  */
4412 static struct alc_config_preset alc880_presets[] = {
4413         [ALC880_3ST] = {
4414                 .mixers = { alc880_three_stack_mixer },
4415                 .init_verbs = { alc880_volume_init_verbs,
4416                                 alc880_pin_3stack_init_verbs },
4417                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4418                 .dac_nids = alc880_dac_nids,
4419                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4420                 .channel_mode = alc880_threestack_modes,
4421                 .need_dac_fix = 1,
4422                 .input_mux = &alc880_capture_source,
4423         },
4424         [ALC880_3ST_DIG] = {
4425                 .mixers = { alc880_three_stack_mixer },
4426                 .init_verbs = { alc880_volume_init_verbs,
4427                                 alc880_pin_3stack_init_verbs },
4428                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4429                 .dac_nids = alc880_dac_nids,
4430                 .dig_out_nid = ALC880_DIGOUT_NID,
4431                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4432                 .channel_mode = alc880_threestack_modes,
4433                 .need_dac_fix = 1,
4434                 .input_mux = &alc880_capture_source,
4435         },
4436         [ALC880_TCL_S700] = {
4437                 .mixers = { alc880_tcl_s700_mixer },
4438                 .init_verbs = { alc880_volume_init_verbs,
4439                                 alc880_pin_tcl_S700_init_verbs,
4440                                 alc880_gpio2_init_verbs },
4441                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4442                 .dac_nids = alc880_dac_nids,
4443                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4444                 .num_adc_nids = 1, /* single ADC */
4445                 .hp_nid = 0x03,
4446                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4447                 .channel_mode = alc880_2_jack_modes,
4448                 .input_mux = &alc880_capture_source,
4449         },
4450         [ALC880_5ST] = {
4451                 .mixers = { alc880_three_stack_mixer,
4452                             alc880_five_stack_mixer},
4453                 .init_verbs = { alc880_volume_init_verbs,
4454                                 alc880_pin_5stack_init_verbs },
4455                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4456                 .dac_nids = alc880_dac_nids,
4457                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4458                 .channel_mode = alc880_fivestack_modes,
4459                 .input_mux = &alc880_capture_source,
4460         },
4461         [ALC880_5ST_DIG] = {
4462                 .mixers = { alc880_three_stack_mixer,
4463                             alc880_five_stack_mixer },
4464                 .init_verbs = { alc880_volume_init_verbs,
4465                                 alc880_pin_5stack_init_verbs },
4466                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4467                 .dac_nids = alc880_dac_nids,
4468                 .dig_out_nid = ALC880_DIGOUT_NID,
4469                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4470                 .channel_mode = alc880_fivestack_modes,
4471                 .input_mux = &alc880_capture_source,
4472         },
4473         [ALC880_6ST] = {
4474                 .mixers = { alc880_six_stack_mixer },
4475                 .init_verbs = { alc880_volume_init_verbs,
4476                                 alc880_pin_6stack_init_verbs },
4477                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4478                 .dac_nids = alc880_6st_dac_nids,
4479                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4480                 .channel_mode = alc880_sixstack_modes,
4481                 .input_mux = &alc880_6stack_capture_source,
4482         },
4483         [ALC880_6ST_DIG] = {
4484                 .mixers = { alc880_six_stack_mixer },
4485                 .init_verbs = { alc880_volume_init_verbs,
4486                                 alc880_pin_6stack_init_verbs },
4487                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4488                 .dac_nids = alc880_6st_dac_nids,
4489                 .dig_out_nid = ALC880_DIGOUT_NID,
4490                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4491                 .channel_mode = alc880_sixstack_modes,
4492                 .input_mux = &alc880_6stack_capture_source,
4493         },
4494         [ALC880_W810] = {
4495                 .mixers = { alc880_w810_base_mixer },
4496                 .init_verbs = { alc880_volume_init_verbs,
4497                                 alc880_pin_w810_init_verbs,
4498                                 alc880_gpio2_init_verbs },
4499                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4500                 .dac_nids = alc880_w810_dac_nids,
4501                 .dig_out_nid = ALC880_DIGOUT_NID,
4502                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4503                 .channel_mode = alc880_w810_modes,
4504                 .input_mux = &alc880_capture_source,
4505         },
4506         [ALC880_Z71V] = {
4507                 .mixers = { alc880_z71v_mixer },
4508                 .init_verbs = { alc880_volume_init_verbs,
4509                                 alc880_pin_z71v_init_verbs },
4510                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4511                 .dac_nids = alc880_z71v_dac_nids,
4512                 .dig_out_nid = ALC880_DIGOUT_NID,
4513                 .hp_nid = 0x03,
4514                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4515                 .channel_mode = alc880_2_jack_modes,
4516                 .input_mux = &alc880_capture_source,
4517         },
4518         [ALC880_F1734] = {
4519                 .mixers = { alc880_f1734_mixer },
4520                 .init_verbs = { alc880_volume_init_verbs,
4521                                 alc880_pin_f1734_init_verbs },
4522                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4523                 .dac_nids = alc880_f1734_dac_nids,
4524                 .hp_nid = 0x02,
4525                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4526                 .channel_mode = alc880_2_jack_modes,
4527                 .input_mux = &alc880_f1734_capture_source,
4528                 .unsol_event = alc880_uniwill_p53_unsol_event,
4529                 .setup = alc880_uniwill_p53_setup,
4530                 .init_hook = alc_automute_amp,
4531         },
4532         [ALC880_ASUS] = {
4533                 .mixers = { alc880_asus_mixer },
4534                 .init_verbs = { alc880_volume_init_verbs,
4535                                 alc880_pin_asus_init_verbs,
4536                                 alc880_gpio1_init_verbs },
4537                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4538                 .dac_nids = alc880_asus_dac_nids,
4539                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4540                 .channel_mode = alc880_asus_modes,
4541                 .need_dac_fix = 1,
4542                 .input_mux = &alc880_capture_source,
4543         },
4544         [ALC880_ASUS_DIG] = {
4545                 .mixers = { alc880_asus_mixer },
4546                 .init_verbs = { alc880_volume_init_verbs,
4547                                 alc880_pin_asus_init_verbs,
4548                                 alc880_gpio1_init_verbs },
4549                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4550                 .dac_nids = alc880_asus_dac_nids,
4551                 .dig_out_nid = ALC880_DIGOUT_NID,
4552                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4553                 .channel_mode = alc880_asus_modes,
4554                 .need_dac_fix = 1,
4555                 .input_mux = &alc880_capture_source,
4556         },
4557         [ALC880_ASUS_DIG2] = {
4558                 .mixers = { alc880_asus_mixer },
4559                 .init_verbs = { alc880_volume_init_verbs,
4560                                 alc880_pin_asus_init_verbs,
4561                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4562                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4563                 .dac_nids = alc880_asus_dac_nids,
4564                 .dig_out_nid = ALC880_DIGOUT_NID,
4565                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4566                 .channel_mode = alc880_asus_modes,
4567                 .need_dac_fix = 1,
4568                 .input_mux = &alc880_capture_source,
4569         },
4570         [ALC880_ASUS_W1V] = {
4571                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4572                 .init_verbs = { alc880_volume_init_verbs,
4573                                 alc880_pin_asus_init_verbs,
4574                                 alc880_gpio1_init_verbs },
4575                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4576                 .dac_nids = alc880_asus_dac_nids,
4577                 .dig_out_nid = ALC880_DIGOUT_NID,
4578                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4579                 .channel_mode = alc880_asus_modes,
4580                 .need_dac_fix = 1,
4581                 .input_mux = &alc880_capture_source,
4582         },
4583         [ALC880_UNIWILL_DIG] = {
4584                 .mixers = { alc880_asus_mixer },
4585                 .init_verbs = { alc880_volume_init_verbs,
4586                                 alc880_pin_asus_init_verbs },
4587                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4588                 .dac_nids = alc880_asus_dac_nids,
4589                 .dig_out_nid = ALC880_DIGOUT_NID,
4590                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4591                 .channel_mode = alc880_asus_modes,
4592                 .need_dac_fix = 1,
4593                 .input_mux = &alc880_capture_source,
4594         },
4595         [ALC880_UNIWILL] = {
4596                 .mixers = { alc880_uniwill_mixer },
4597                 .init_verbs = { alc880_volume_init_verbs,
4598                                 alc880_uniwill_init_verbs },
4599                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4600                 .dac_nids = alc880_asus_dac_nids,
4601                 .dig_out_nid = ALC880_DIGOUT_NID,
4602                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4603                 .channel_mode = alc880_threestack_modes,
4604                 .need_dac_fix = 1,
4605                 .input_mux = &alc880_capture_source,
4606                 .unsol_event = alc880_uniwill_unsol_event,
4607                 .setup = alc880_uniwill_setup,
4608                 .init_hook = alc880_uniwill_init_hook,
4609         },
4610         [ALC880_UNIWILL_P53] = {
4611                 .mixers = { alc880_uniwill_p53_mixer },
4612                 .init_verbs = { alc880_volume_init_verbs,
4613                                 alc880_uniwill_p53_init_verbs },
4614                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4615                 .dac_nids = alc880_asus_dac_nids,
4616                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4617                 .channel_mode = alc880_threestack_modes,
4618                 .input_mux = &alc880_capture_source,
4619                 .unsol_event = alc880_uniwill_p53_unsol_event,
4620                 .setup = alc880_uniwill_p53_setup,
4621                 .init_hook = alc_automute_amp,
4622         },
4623         [ALC880_FUJITSU] = {
4624                 .mixers = { alc880_fujitsu_mixer },
4625                 .init_verbs = { alc880_volume_init_verbs,
4626                                 alc880_uniwill_p53_init_verbs,
4627                                 alc880_beep_init_verbs },
4628                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4629                 .dac_nids = alc880_dac_nids,
4630                 .dig_out_nid = ALC880_DIGOUT_NID,
4631                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4632                 .channel_mode = alc880_2_jack_modes,
4633                 .input_mux = &alc880_capture_source,
4634                 .unsol_event = alc880_uniwill_p53_unsol_event,
4635                 .setup = alc880_uniwill_p53_setup,
4636                 .init_hook = alc_automute_amp,
4637         },
4638         [ALC880_CLEVO] = {
4639                 .mixers = { alc880_three_stack_mixer },
4640                 .init_verbs = { alc880_volume_init_verbs,
4641                                 alc880_pin_clevo_init_verbs },
4642                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4643                 .dac_nids = alc880_dac_nids,
4644                 .hp_nid = 0x03,
4645                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4646                 .channel_mode = alc880_threestack_modes,
4647                 .need_dac_fix = 1,
4648                 .input_mux = &alc880_capture_source,
4649         },
4650         [ALC880_LG] = {
4651                 .mixers = { alc880_lg_mixer },
4652                 .init_verbs = { alc880_volume_init_verbs,
4653                                 alc880_lg_init_verbs },
4654                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4655                 .dac_nids = alc880_lg_dac_nids,
4656                 .dig_out_nid = ALC880_DIGOUT_NID,
4657                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4658                 .channel_mode = alc880_lg_ch_modes,
4659                 .need_dac_fix = 1,
4660                 .input_mux = &alc880_lg_capture_source,
4661                 .unsol_event = alc_automute_amp_unsol_event,
4662                 .setup = alc880_lg_setup,
4663                 .init_hook = alc_automute_amp,
4664 #ifdef CONFIG_SND_HDA_POWER_SAVE
4665                 .loopbacks = alc880_lg_loopbacks,
4666 #endif
4667         },
4668         [ALC880_LG_LW] = {
4669                 .mixers = { alc880_lg_lw_mixer },
4670                 .init_verbs = { alc880_volume_init_verbs,
4671                                 alc880_lg_lw_init_verbs },
4672                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4673                 .dac_nids = alc880_dac_nids,
4674                 .dig_out_nid = ALC880_DIGOUT_NID,
4675                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4676                 .channel_mode = alc880_lg_lw_modes,
4677                 .input_mux = &alc880_lg_lw_capture_source,
4678                 .unsol_event = alc_automute_amp_unsol_event,
4679                 .setup = alc880_lg_lw_setup,
4680                 .init_hook = alc_automute_amp,
4681         },
4682         [ALC880_MEDION_RIM] = {
4683                 .mixers = { alc880_medion_rim_mixer },
4684                 .init_verbs = { alc880_volume_init_verbs,
4685                                 alc880_medion_rim_init_verbs,
4686                                 alc_gpio2_init_verbs },
4687                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4688                 .dac_nids = alc880_dac_nids,
4689                 .dig_out_nid = ALC880_DIGOUT_NID,
4690                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4691                 .channel_mode = alc880_2_jack_modes,
4692                 .input_mux = &alc880_medion_rim_capture_source,
4693                 .unsol_event = alc880_medion_rim_unsol_event,
4694                 .setup = alc880_medion_rim_setup,
4695                 .init_hook = alc880_medion_rim_automute,
4696         },
4697 #ifdef CONFIG_SND_DEBUG
4698         [ALC880_TEST] = {
4699                 .mixers = { alc880_test_mixer },
4700                 .init_verbs = { alc880_test_init_verbs },
4701                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4702                 .dac_nids = alc880_test_dac_nids,
4703                 .dig_out_nid = ALC880_DIGOUT_NID,
4704                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4705                 .channel_mode = alc880_test_modes,
4706                 .input_mux = &alc880_test_capture_source,
4707         },
4708 #endif
4709 };
4710
4711 /*
4712  * Automatic parse of I/O pins from the BIOS configuration
4713  */
4714
4715 enum {
4716         ALC_CTL_WIDGET_VOL,
4717         ALC_CTL_WIDGET_MUTE,
4718         ALC_CTL_BIND_MUTE,
4719 };
4720 static struct snd_kcontrol_new alc880_control_templates[] = {
4721         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4722         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4723         HDA_BIND_MUTE(NULL, 0, 0, 0),
4724 };
4725
4726 /* add dynamic controls */
4727 static int add_control(struct alc_spec *spec, int type, const char *name,
4728                        int cidx, unsigned long val)
4729 {
4730         struct snd_kcontrol_new *knew;
4731
4732         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4733         knew = snd_array_new(&spec->kctls);
4734         if (!knew)
4735                 return -ENOMEM;
4736         *knew = alc880_control_templates[type];
4737         knew->name = kstrdup(name, GFP_KERNEL);
4738         if (!knew->name)
4739                 return -ENOMEM;
4740         knew->index = cidx;
4741         if (get_amp_nid_(val))
4742                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4743         knew->private_value = val;
4744         return 0;
4745 }
4746
4747 static int add_control_with_pfx(struct alc_spec *spec, int type,
4748                                 const char *pfx, const char *dir,
4749                                 const char *sfx, int cidx, unsigned long val)
4750 {
4751         char name[32];
4752         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4753         return add_control(spec, type, name, cidx, val);
4754 }
4755
4756 #define add_pb_vol_ctrl(spec, type, pfx, val)                   \
4757         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", 0, val)
4758 #define add_pb_sw_ctrl(spec, type, pfx, val)                    \
4759         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", 0, val)
4760 #define __add_pb_vol_ctrl(spec, type, pfx, cidx, val)                   \
4761         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", cidx, val)
4762 #define __add_pb_sw_ctrl(spec, type, pfx, cidx, val)                    \
4763         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", cidx, val)
4764
4765 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4766 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4767 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4768 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4769 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4770 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4771 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4772 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4773 #define ALC880_PIN_CD_NID               0x1c
4774
4775 /* fill in the dac_nids table from the parsed pin configuration */
4776 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4777                                      const struct auto_pin_cfg *cfg)
4778 {
4779         hda_nid_t nid;
4780         int assigned[4];
4781         int i, j;
4782
4783         memset(assigned, 0, sizeof(assigned));
4784         spec->multiout.dac_nids = spec->private_dac_nids;
4785
4786         /* check the pins hardwired to audio widget */
4787         for (i = 0; i < cfg->line_outs; i++) {
4788                 nid = cfg->line_out_pins[i];
4789                 if (alc880_is_fixed_pin(nid)) {
4790                         int idx = alc880_fixed_pin_idx(nid);
4791                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4792                         assigned[idx] = 1;
4793                 }
4794         }
4795         /* left pins can be connect to any audio widget */
4796         for (i = 0; i < cfg->line_outs; i++) {
4797                 nid = cfg->line_out_pins[i];
4798                 if (alc880_is_fixed_pin(nid))
4799                         continue;
4800                 /* search for an empty channel */
4801                 for (j = 0; j < cfg->line_outs; j++) {
4802                         if (!assigned[j]) {
4803                                 spec->multiout.dac_nids[i] =
4804                                         alc880_idx_to_dac(j);
4805                                 assigned[j] = 1;
4806                                 break;
4807                         }
4808                 }
4809         }
4810         spec->multiout.num_dacs = cfg->line_outs;
4811         return 0;
4812 }
4813
4814 /* add playback controls from the parsed DAC table */
4815 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4816                                              const struct auto_pin_cfg *cfg)
4817 {
4818         static const char *chname[4] = {
4819                 "Front", "Surround", NULL /*CLFE*/, "Side"
4820         };
4821         hda_nid_t nid;
4822         int i, err;
4823
4824         for (i = 0; i < cfg->line_outs; i++) {
4825                 if (!spec->multiout.dac_nids[i])
4826                         continue;
4827                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4828                 if (i == 2) {
4829                         /* Center/LFE */
4830                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4831                                               "Center",
4832                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4833                                                               HDA_OUTPUT));
4834                         if (err < 0)
4835                                 return err;
4836                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4837                                               "LFE",
4838                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4839                                                               HDA_OUTPUT));
4840                         if (err < 0)
4841                                 return err;
4842                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4843                                              "Center",
4844                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4845                                                               HDA_INPUT));
4846                         if (err < 0)
4847                                 return err;
4848                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4849                                              "LFE",
4850                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4851                                                               HDA_INPUT));
4852                         if (err < 0)
4853                                 return err;
4854                 } else {
4855                         const char *pfx;
4856                         if (cfg->line_outs == 1 &&
4857                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4858                                 pfx = "Speaker";
4859                         else
4860                                 pfx = chname[i];
4861                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4862                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4863                                                               HDA_OUTPUT));
4864                         if (err < 0)
4865                                 return err;
4866                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4867                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4868                                                               HDA_INPUT));
4869                         if (err < 0)
4870                                 return err;
4871                 }
4872         }
4873         return 0;
4874 }
4875
4876 /* add playback controls for speaker and HP outputs */
4877 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4878                                         const char *pfx)
4879 {
4880         hda_nid_t nid;
4881         int err;
4882
4883         if (!pin)
4884                 return 0;
4885
4886         if (alc880_is_fixed_pin(pin)) {
4887                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4888                 /* specify the DAC as the extra output */
4889                 if (!spec->multiout.hp_nid)
4890                         spec->multiout.hp_nid = nid;
4891                 else
4892                         spec->multiout.extra_out_nid[0] = nid;
4893                 /* control HP volume/switch on the output mixer amp */
4894                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4895                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4896                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4897                 if (err < 0)
4898                         return err;
4899                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4900                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4901                 if (err < 0)
4902                         return err;
4903         } else if (alc880_is_multi_pin(pin)) {
4904                 /* set manual connection */
4905                 /* we have only a switch on HP-out PIN */
4906                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4907                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4908                 if (err < 0)
4909                         return err;
4910         }
4911         return 0;
4912 }
4913
4914 /* create input playback/capture controls for the given pin */
4915 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4916                             const char *ctlname, int ctlidx,
4917                             int idx, hda_nid_t mix_nid)
4918 {
4919         int err;
4920
4921         err = __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname, ctlidx,
4922                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4923         if (err < 0)
4924                 return err;
4925         err = __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname, ctlidx,
4926                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4927         if (err < 0)
4928                 return err;
4929         return 0;
4930 }
4931
4932 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4933 {
4934         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4935         return (pincap & AC_PINCAP_IN) != 0;
4936 }
4937
4938 /* create playback/capture controls for input pins */
4939 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4940                                       const struct auto_pin_cfg *cfg,
4941                                       hda_nid_t mixer,
4942                                       hda_nid_t cap1, hda_nid_t cap2)
4943 {
4944         struct alc_spec *spec = codec->spec;
4945         struct hda_input_mux *imux = &spec->private_imux[0];
4946         int i, err, idx, type, type_idx = 0;
4947
4948         for (i = 0; i < cfg->num_inputs; i++) {
4949                 hda_nid_t pin;
4950
4951                 pin = cfg->inputs[i].pin;
4952                 if (!alc_is_input_pin(codec, pin))
4953                         continue;
4954
4955                 type = cfg->inputs[i].type;
4956                 if (i > 0 && type == cfg->inputs[i - 1].type)
4957                         type_idx++;
4958                 else
4959                         type_idx = 0;
4960                 if (mixer) {
4961                         idx = get_connection_index(codec, mixer, pin);
4962                         if (idx >= 0) {
4963                                 err = new_analog_input(spec, pin,
4964                                                        auto_pin_cfg_labels[type],
4965                                                        type_idx, idx, mixer);
4966                                 if (err < 0)
4967                                         return err;
4968                         }
4969                 }
4970
4971                 if (!cap1)
4972                         continue;
4973                 idx = get_connection_index(codec, cap1, pin);
4974                 if (idx < 0 && cap2)
4975                         idx = get_connection_index(codec, cap2, pin);
4976                 if (idx >= 0) {
4977                         imux->items[imux->num_items].label =
4978                                 snd_hda_get_input_pin_label(cfg, i);
4979                         imux->items[imux->num_items].index = idx;
4980                         imux->num_items++;
4981                 }
4982         }
4983         return 0;
4984 }
4985
4986 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4987                                                 const struct auto_pin_cfg *cfg)
4988 {
4989         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4990 }
4991
4992 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4993                                unsigned int pin_type)
4994 {
4995         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4996                             pin_type);
4997         /* unmute pin */
4998         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4999                             AMP_OUT_UNMUTE);
5000 }
5001
5002 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
5003                                               hda_nid_t nid, int pin_type,
5004                                               int dac_idx)
5005 {
5006         alc_set_pin_output(codec, nid, pin_type);
5007         /* need the manual connection? */
5008         if (alc880_is_multi_pin(nid)) {
5009                 struct alc_spec *spec = codec->spec;
5010                 int idx = alc880_multi_pin_idx(nid);
5011                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
5012                                     AC_VERB_SET_CONNECT_SEL,
5013                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
5014         }
5015 }
5016
5017 static int get_pin_type(int line_out_type)
5018 {
5019         if (line_out_type == AUTO_PIN_HP_OUT)
5020                 return PIN_HP;
5021         else
5022                 return PIN_OUT;
5023 }
5024
5025 static void alc880_auto_init_multi_out(struct hda_codec *codec)
5026 {
5027         struct alc_spec *spec = codec->spec;
5028         int i;
5029
5030         for (i = 0; i < spec->autocfg.line_outs; i++) {
5031                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
5032                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
5033                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
5034         }
5035 }
5036
5037 static void alc880_auto_init_extra_out(struct hda_codec *codec)
5038 {
5039         struct alc_spec *spec = codec->spec;
5040         hda_nid_t pin;
5041
5042         pin = spec->autocfg.speaker_pins[0];
5043         if (pin) /* connect to front */
5044                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
5045         pin = spec->autocfg.hp_pins[0];
5046         if (pin) /* connect to front */
5047                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
5048 }
5049
5050 static void alc880_auto_init_analog_input(struct hda_codec *codec)
5051 {
5052         struct alc_spec *spec = codec->spec;
5053         struct auto_pin_cfg *cfg = &spec->autocfg;
5054         int i;
5055
5056         for (i = 0; i < cfg->num_inputs; i++) {
5057                 hda_nid_t nid = cfg->inputs[i].pin;
5058                 if (alc_is_input_pin(codec, nid)) {
5059                         alc_set_input_pin(codec, nid, i);
5060                         if (nid != ALC880_PIN_CD_NID &&
5061                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
5062                                 snd_hda_codec_write(codec, nid, 0,
5063                                                     AC_VERB_SET_AMP_GAIN_MUTE,
5064                                                     AMP_OUT_MUTE);
5065                 }
5066         }
5067 }
5068
5069 static void alc880_auto_init_input_src(struct hda_codec *codec)
5070 {
5071         struct alc_spec *spec = codec->spec;
5072         int c;
5073
5074         for (c = 0; c < spec->num_adc_nids; c++) {
5075                 unsigned int mux_idx;
5076                 const struct hda_input_mux *imux;
5077                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
5078                 imux = &spec->input_mux[mux_idx];
5079                 if (!imux->num_items && mux_idx > 0)
5080                         imux = &spec->input_mux[0];
5081                 if (imux)
5082                         snd_hda_codec_write(codec, spec->adc_nids[c], 0,
5083                                             AC_VERB_SET_CONNECT_SEL,
5084                                             imux->items[0].index);
5085         }
5086 }
5087
5088 /* parse the BIOS configuration and set up the alc_spec */
5089 /* return 1 if successful, 0 if the proper config is not found,
5090  * or a negative error code
5091  */
5092 static int alc880_parse_auto_config(struct hda_codec *codec)
5093 {
5094         struct alc_spec *spec = codec->spec;
5095         int err;
5096         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
5097
5098         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
5099                                            alc880_ignore);
5100         if (err < 0)
5101                 return err;
5102         if (!spec->autocfg.line_outs)
5103                 return 0; /* can't find valid BIOS pin config */
5104
5105         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
5106         if (err < 0)
5107                 return err;
5108         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
5109         if (err < 0)
5110                 return err;
5111         err = alc880_auto_create_extra_out(spec,
5112                                            spec->autocfg.speaker_pins[0],
5113                                            "Speaker");
5114         if (err < 0)
5115                 return err;
5116         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
5117                                            "Headphone");
5118         if (err < 0)
5119                 return err;
5120         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
5121         if (err < 0)
5122                 return err;
5123
5124         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
5125
5126         alc_auto_parse_digital(codec);
5127
5128         if (spec->kctls.list)
5129                 add_mixer(spec, spec->kctls.list);
5130
5131         add_verb(spec, alc880_volume_init_verbs);
5132
5133         spec->num_mux_defs = 1;
5134         spec->input_mux = &spec->private_imux[0];
5135
5136         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
5137
5138         return 1;
5139 }
5140
5141 /* additional initialization for auto-configuration model */
5142 static void alc880_auto_init(struct hda_codec *codec)
5143 {
5144         struct alc_spec *spec = codec->spec;
5145         alc880_auto_init_multi_out(codec);
5146         alc880_auto_init_extra_out(codec);
5147         alc880_auto_init_analog_input(codec);
5148         alc880_auto_init_input_src(codec);
5149         alc_auto_init_digital(codec);
5150         if (spec->unsol_event)
5151                 alc_inithook(codec);
5152 }
5153
5154 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
5155  * one of two digital mic pins, e.g. on ALC272
5156  */
5157 static void fixup_automic_adc(struct hda_codec *codec)
5158 {
5159         struct alc_spec *spec = codec->spec;
5160         int i;
5161
5162         for (i = 0; i < spec->num_adc_nids; i++) {
5163                 hda_nid_t cap = spec->capsrc_nids ?
5164                         spec->capsrc_nids[i] : spec->adc_nids[i];
5165                 int iidx, eidx;
5166
5167                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
5168                 if (iidx < 0)
5169                         continue;
5170                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
5171                 if (eidx < 0)
5172                         continue;
5173                 spec->int_mic.mux_idx = iidx;
5174                 spec->ext_mic.mux_idx = eidx;
5175                 if (spec->capsrc_nids)
5176                         spec->capsrc_nids += i;
5177                 spec->adc_nids += i;
5178                 spec->num_adc_nids = 1;
5179                 return;
5180         }
5181         snd_printd(KERN_INFO "hda_codec: %s: "
5182                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
5183                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
5184         spec->auto_mic = 0; /* disable auto-mic to be sure */
5185 }
5186
5187 /* select or unmute the given capsrc route */
5188 static void select_or_unmute_capsrc(struct hda_codec *codec, hda_nid_t cap,
5189                                     int idx)
5190 {
5191         if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
5192                 snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
5193                                          HDA_AMP_MUTE, 0);
5194         } else {
5195                 snd_hda_codec_write_cache(codec, cap, 0,
5196                                           AC_VERB_SET_CONNECT_SEL, idx);
5197         }
5198 }
5199
5200 /* set the default connection to that pin */
5201 static int init_capsrc_for_pin(struct hda_codec *codec, hda_nid_t pin)
5202 {
5203         struct alc_spec *spec = codec->spec;
5204         int i;
5205
5206         for (i = 0; i < spec->num_adc_nids; i++) {
5207                 hda_nid_t cap = spec->capsrc_nids ?
5208                         spec->capsrc_nids[i] : spec->adc_nids[i];
5209                 int idx;
5210
5211                 idx = get_connection_index(codec, cap, pin);
5212                 if (idx < 0)
5213                         continue;
5214                 select_or_unmute_capsrc(codec, cap, idx);
5215                 return i; /* return the found index */
5216         }
5217         return -1; /* not found */
5218 }
5219
5220 /* choose the ADC/MUX containing the input pin and initialize the setup */
5221 static void fixup_single_adc(struct hda_codec *codec)
5222 {
5223         struct alc_spec *spec = codec->spec;
5224         struct auto_pin_cfg *cfg = &spec->autocfg;
5225         int i;
5226
5227         /* search for the input pin; there must be only one */
5228         if (cfg->num_inputs != 1)
5229                 return;
5230         i = init_capsrc_for_pin(codec, cfg->inputs[0].pin);
5231         if (i >= 0) {
5232                 /* use only this ADC */
5233                 if (spec->capsrc_nids)
5234                         spec->capsrc_nids += i;
5235                 spec->adc_nids += i;
5236                 spec->num_adc_nids = 1;
5237         }
5238 }
5239
5240 /* initialize dual adcs */
5241 static void fixup_dual_adc_switch(struct hda_codec *codec)
5242 {
5243         struct alc_spec *spec = codec->spec;
5244         init_capsrc_for_pin(codec, spec->ext_mic.pin);
5245         init_capsrc_for_pin(codec, spec->int_mic.pin);
5246 }
5247
5248 static void set_capture_mixer(struct hda_codec *codec)
5249 {
5250         struct alc_spec *spec = codec->spec;
5251         static struct snd_kcontrol_new *caps[2][3] = {
5252                 { alc_capture_mixer_nosrc1,
5253                   alc_capture_mixer_nosrc2,
5254                   alc_capture_mixer_nosrc3 },
5255                 { alc_capture_mixer1,
5256                   alc_capture_mixer2,
5257                   alc_capture_mixer3 },
5258         };
5259         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
5260                 int mux = 0;
5261                 int num_adcs = spec->num_adc_nids;
5262                 if (spec->dual_adc_switch)
5263                         fixup_dual_adc_switch(codec);
5264                 else if (spec->auto_mic)
5265                         fixup_automic_adc(codec);
5266                 else if (spec->input_mux) {
5267                         if (spec->input_mux->num_items > 1)
5268                                 mux = 1;
5269                         else if (spec->input_mux->num_items == 1)
5270                                 fixup_single_adc(codec);
5271                 }
5272                 if (spec->dual_adc_switch)
5273                         num_adcs = 1;
5274                 spec->cap_mixer = caps[mux][num_adcs - 1];
5275         }
5276 }
5277
5278 /* fill adc_nids (and capsrc_nids) containing all active input pins */
5279 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
5280                                  int num_nids)
5281 {
5282         struct alc_spec *spec = codec->spec;
5283         struct auto_pin_cfg *cfg = &spec->autocfg;
5284         int n;
5285         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5286
5287         for (n = 0; n < num_nids; n++) {
5288                 hda_nid_t adc, cap;
5289                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5290                 int nconns, i, j;
5291
5292                 adc = nids[n];
5293                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5294                         continue;
5295                 cap = adc;
5296                 nconns = snd_hda_get_connections(codec, cap, conn,
5297                                                  ARRAY_SIZE(conn));
5298                 if (nconns == 1) {
5299                         cap = conn[0];
5300                         nconns = snd_hda_get_connections(codec, cap, conn,
5301                                                          ARRAY_SIZE(conn));
5302                 }
5303                 if (nconns <= 0)
5304                         continue;
5305                 if (!fallback_adc) {
5306                         fallback_adc = adc;
5307                         fallback_cap = cap;
5308                 }
5309                 for (i = 0; i < cfg->num_inputs; i++) {
5310                         hda_nid_t nid = cfg->inputs[i].pin;
5311                         for (j = 0; j < nconns; j++) {
5312                                 if (conn[j] == nid)
5313                                         break;
5314                         }
5315                         if (j >= nconns)
5316                                 break;
5317                 }
5318                 if (i >= cfg->num_inputs) {
5319                         int num_adcs = spec->num_adc_nids;
5320                         spec->private_adc_nids[num_adcs] = adc;
5321                         spec->private_capsrc_nids[num_adcs] = cap;
5322                         spec->num_adc_nids++;
5323                         spec->adc_nids = spec->private_adc_nids;
5324                         if (adc != cap)
5325                                 spec->capsrc_nids = spec->private_capsrc_nids;
5326                 }
5327         }
5328         if (!spec->num_adc_nids) {
5329                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5330                        " using fallback 0x%x\n",
5331                        codec->chip_name, fallback_adc);
5332                 spec->private_adc_nids[0] = fallback_adc;
5333                 spec->adc_nids = spec->private_adc_nids;
5334                 if (fallback_adc != fallback_cap) {
5335                         spec->private_capsrc_nids[0] = fallback_cap;
5336                         spec->capsrc_nids = spec->private_adc_nids;
5337                 }
5338         }
5339 }
5340
5341 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5342 #define set_beep_amp(spec, nid, idx, dir) \
5343         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5344
5345 static struct snd_pci_quirk beep_white_list[] = {
5346         SND_PCI_QUIRK(0x1043, 0x829f, "ASUS", 1),
5347         SND_PCI_QUIRK(0x1043, 0x83ce, "EeePC", 1),
5348         SND_PCI_QUIRK(0x8086, 0xd613, "Intel", 1),
5349         {}
5350 };
5351
5352 static inline int has_cdefine_beep(struct hda_codec *codec)
5353 {
5354         struct alc_spec *spec = codec->spec;
5355         const struct snd_pci_quirk *q;
5356         q = snd_pci_quirk_lookup(codec->bus->pci, beep_white_list);
5357         if (q)
5358                 return q->value;
5359         return spec->cdefine.enable_pcbeep;
5360 }
5361 #else
5362 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5363 #define has_cdefine_beep(codec)         0
5364 #endif
5365
5366 /*
5367  * OK, here we have finally the patch for ALC880
5368  */
5369
5370 static int patch_alc880(struct hda_codec *codec)
5371 {
5372         struct alc_spec *spec;
5373         int board_config;
5374         int err;
5375
5376         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5377         if (spec == NULL)
5378                 return -ENOMEM;
5379
5380         codec->spec = spec;
5381
5382         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5383                                                   alc880_models,
5384                                                   alc880_cfg_tbl);
5385         if (board_config < 0) {
5386                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5387                        codec->chip_name);
5388                 board_config = ALC880_AUTO;
5389         }
5390
5391         if (board_config == ALC880_AUTO) {
5392                 /* automatic parse from the BIOS config */
5393                 err = alc880_parse_auto_config(codec);
5394                 if (err < 0) {
5395                         alc_free(codec);
5396                         return err;
5397                 } else if (!err) {
5398                         printk(KERN_INFO
5399                                "hda_codec: Cannot set up configuration "
5400                                "from BIOS.  Using 3-stack mode...\n");
5401                         board_config = ALC880_3ST;
5402                 }
5403         }
5404
5405         err = snd_hda_attach_beep_device(codec, 0x1);
5406         if (err < 0) {
5407                 alc_free(codec);
5408                 return err;
5409         }
5410
5411         if (board_config != ALC880_AUTO)
5412                 setup_preset(codec, &alc880_presets[board_config]);
5413
5414         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5415         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5416         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5417
5418         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5419         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5420
5421         if (!spec->adc_nids && spec->input_mux) {
5422                 /* check whether NID 0x07 is valid */
5423                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5424                 /* get type */
5425                 wcap = get_wcaps_type(wcap);
5426                 if (wcap != AC_WID_AUD_IN) {
5427                         spec->adc_nids = alc880_adc_nids_alt;
5428                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5429                 } else {
5430                         spec->adc_nids = alc880_adc_nids;
5431                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5432                 }
5433         }
5434         set_capture_mixer(codec);
5435         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5436
5437         spec->vmaster_nid = 0x0c;
5438
5439         codec->patch_ops = alc_patch_ops;
5440         if (board_config == ALC880_AUTO)
5441                 spec->init_hook = alc880_auto_init;
5442 #ifdef CONFIG_SND_HDA_POWER_SAVE
5443         if (!spec->loopback.amplist)
5444                 spec->loopback.amplist = alc880_loopbacks;
5445 #endif
5446
5447         return 0;
5448 }
5449
5450
5451 /*
5452  * ALC260 support
5453  */
5454
5455 static hda_nid_t alc260_dac_nids[1] = {
5456         /* front */
5457         0x02,
5458 };
5459
5460 static hda_nid_t alc260_adc_nids[1] = {
5461         /* ADC0 */
5462         0x04,
5463 };
5464
5465 static hda_nid_t alc260_adc_nids_alt[1] = {
5466         /* ADC1 */
5467         0x05,
5468 };
5469
5470 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5471  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5472  */
5473 static hda_nid_t alc260_dual_adc_nids[2] = {
5474         /* ADC0, ADC1 */
5475         0x04, 0x05
5476 };
5477
5478 #define ALC260_DIGOUT_NID       0x03
5479 #define ALC260_DIGIN_NID        0x06
5480
5481 static struct hda_input_mux alc260_capture_source = {
5482         .num_items = 4,
5483         .items = {
5484                 { "Mic", 0x0 },
5485                 { "Front Mic", 0x1 },
5486                 { "Line", 0x2 },
5487                 { "CD", 0x4 },
5488         },
5489 };
5490
5491 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5492  * headphone jack and the internal CD lines since these are the only pins at
5493  * which audio can appear.  For flexibility, also allow the option of
5494  * recording the mixer output on the second ADC (ADC0 doesn't have a
5495  * connection to the mixer output).
5496  */
5497 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5498         {
5499                 .num_items = 3,
5500                 .items = {
5501                         { "Mic/Line", 0x0 },
5502                         { "CD", 0x4 },
5503                         { "Headphone", 0x2 },
5504                 },
5505         },
5506         {
5507                 .num_items = 4,
5508                 .items = {
5509                         { "Mic/Line", 0x0 },
5510                         { "CD", 0x4 },
5511                         { "Headphone", 0x2 },
5512                         { "Mixer", 0x5 },
5513                 },
5514         },
5515
5516 };
5517
5518 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5519  * the Fujitsu S702x, but jacks are marked differently.
5520  */
5521 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5522         {
5523                 .num_items = 4,
5524                 .items = {
5525                         { "Mic", 0x0 },
5526                         { "Line", 0x2 },
5527                         { "CD", 0x4 },
5528                         { "Headphone", 0x5 },
5529                 },
5530         },
5531         {
5532                 .num_items = 5,
5533                 .items = {
5534                         { "Mic", 0x0 },
5535                         { "Line", 0x2 },
5536                         { "CD", 0x4 },
5537                         { "Headphone", 0x6 },
5538                         { "Mixer", 0x5 },
5539                 },
5540         },
5541 };
5542
5543 /* Maxdata Favorit 100XS */
5544 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5545         {
5546                 .num_items = 2,
5547                 .items = {
5548                         { "Line/Mic", 0x0 },
5549                         { "CD", 0x4 },
5550                 },
5551         },
5552         {
5553                 .num_items = 3,
5554                 .items = {
5555                         { "Line/Mic", 0x0 },
5556                         { "CD", 0x4 },
5557                         { "Mixer", 0x5 },
5558                 },
5559         },
5560 };
5561
5562 /*
5563  * This is just place-holder, so there's something for alc_build_pcms to look
5564  * at when it calculates the maximum number of channels. ALC260 has no mixer
5565  * element which allows changing the channel mode, so the verb list is
5566  * never used.
5567  */
5568 static struct hda_channel_mode alc260_modes[1] = {
5569         { 2, NULL },
5570 };
5571
5572
5573 /* Mixer combinations
5574  *
5575  * basic: base_output + input + pc_beep + capture
5576  * HP: base_output + input + capture_alt
5577  * HP_3013: hp_3013 + input + capture
5578  * fujitsu: fujitsu + capture
5579  * acer: acer + capture
5580  */
5581
5582 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5583         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5584         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5585         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5586         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5587         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5588         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5589         { } /* end */
5590 };
5591
5592 static struct snd_kcontrol_new alc260_input_mixer[] = {
5593         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5594         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5595         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5596         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5597         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5598         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5599         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5600         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5601         { } /* end */
5602 };
5603
5604 /* update HP, line and mono out pins according to the master switch */
5605 static void alc260_hp_master_update(struct hda_codec *codec,
5606                                     hda_nid_t hp, hda_nid_t line,
5607                                     hda_nid_t mono)
5608 {
5609         struct alc_spec *spec = codec->spec;
5610         unsigned int val = spec->master_sw ? PIN_HP : 0;
5611         /* change HP and line-out pins */
5612         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5613                             val);
5614         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5615                             val);
5616         /* mono (speaker) depending on the HP jack sense */
5617         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5618         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5619                             val);
5620 }
5621
5622 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5623                                    struct snd_ctl_elem_value *ucontrol)
5624 {
5625         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5626         struct alc_spec *spec = codec->spec;
5627         *ucontrol->value.integer.value = spec->master_sw;
5628         return 0;
5629 }
5630
5631 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5632                                    struct snd_ctl_elem_value *ucontrol)
5633 {
5634         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5635         struct alc_spec *spec = codec->spec;
5636         int val = !!*ucontrol->value.integer.value;
5637         hda_nid_t hp, line, mono;
5638
5639         if (val == spec->master_sw)
5640                 return 0;
5641         spec->master_sw = val;
5642         hp = (kcontrol->private_value >> 16) & 0xff;
5643         line = (kcontrol->private_value >> 8) & 0xff;
5644         mono = kcontrol->private_value & 0xff;
5645         alc260_hp_master_update(codec, hp, line, mono);
5646         return 1;
5647 }
5648
5649 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5650         {
5651                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5652                 .name = "Master Playback Switch",
5653                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5654                 .info = snd_ctl_boolean_mono_info,
5655                 .get = alc260_hp_master_sw_get,
5656                 .put = alc260_hp_master_sw_put,
5657                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5658         },
5659         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5660         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5661         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5662         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5663         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5664                               HDA_OUTPUT),
5665         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5666         { } /* end */
5667 };
5668
5669 static struct hda_verb alc260_hp_unsol_verbs[] = {
5670         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5671         {},
5672 };
5673
5674 static void alc260_hp_automute(struct hda_codec *codec)
5675 {
5676         struct alc_spec *spec = codec->spec;
5677
5678         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5679         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5680 }
5681
5682 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5683 {
5684         if ((res >> 26) == ALC880_HP_EVENT)
5685                 alc260_hp_automute(codec);
5686 }
5687
5688 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5689         {
5690                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5691                 .name = "Master Playback Switch",
5692                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5693                 .info = snd_ctl_boolean_mono_info,
5694                 .get = alc260_hp_master_sw_get,
5695                 .put = alc260_hp_master_sw_put,
5696                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5697         },
5698         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5699         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5700         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5701         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5702         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5703         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5704         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5705         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5706         { } /* end */
5707 };
5708
5709 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5710         .ops = &snd_hda_bind_vol,
5711         .values = {
5712                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5713                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5714                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5715                 0
5716         },
5717 };
5718
5719 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5720         .ops = &snd_hda_bind_sw,
5721         .values = {
5722                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5723                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5724                 0
5725         },
5726 };
5727
5728 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5729         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5730         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5731         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5732         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5733         { } /* end */
5734 };
5735
5736 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5737         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5738         {},
5739 };
5740
5741 static void alc260_hp_3013_automute(struct hda_codec *codec)
5742 {
5743         struct alc_spec *spec = codec->spec;
5744
5745         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5746         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5747 }
5748
5749 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5750                                        unsigned int res)
5751 {
5752         if ((res >> 26) == ALC880_HP_EVENT)
5753                 alc260_hp_3013_automute(codec);
5754 }
5755
5756 static void alc260_hp_3012_automute(struct hda_codec *codec)
5757 {
5758         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5759
5760         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5761                             bits);
5762         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5763                             bits);
5764         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5765                             bits);
5766 }
5767
5768 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5769                                        unsigned int res)
5770 {
5771         if ((res >> 26) == ALC880_HP_EVENT)
5772                 alc260_hp_3012_automute(codec);
5773 }
5774
5775 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5776  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5777  */
5778 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5779         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5780         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5781         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5782         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5783         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5784         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5785         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5786         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5787         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5788         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5789         { } /* end */
5790 };
5791
5792 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5793  * versions of the ALC260 don't act on requests to enable mic bias from NID
5794  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5795  * datasheet doesn't mention this restriction.  At this stage it's not clear
5796  * whether this behaviour is intentional or is a hardware bug in chip
5797  * revisions available in early 2006.  Therefore for now allow the
5798  * "Headphone Jack Mode" control to span all choices, but if it turns out
5799  * that the lack of mic bias for this NID is intentional we could change the
5800  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5801  *
5802  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5803  * don't appear to make the mic bias available from the "line" jack, even
5804  * though the NID used for this jack (0x14) can supply it.  The theory is
5805  * that perhaps Acer have included blocking capacitors between the ALC260
5806  * and the output jack.  If this turns out to be the case for all such
5807  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5808  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5809  *
5810  * The C20x Tablet series have a mono internal speaker which is controlled
5811  * via the chip's Mono sum widget and pin complex, so include the necessary
5812  * controls for such models.  On models without a "mono speaker" the control
5813  * won't do anything.
5814  */
5815 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5816         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5817         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5818         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5819         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5820                               HDA_OUTPUT),
5821         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5822                            HDA_INPUT),
5823         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5824         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5825         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5826         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5827         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5828         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5829         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5830         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5831         { } /* end */
5832 };
5833
5834 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5835  */
5836 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5837         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5838         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5839         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5840         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5841         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5842         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5843         { } /* end */
5844 };
5845
5846 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5847  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5848  */
5849 static struct snd_kcontrol_new alc260_will_mixer[] = {
5850         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5851         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5852         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5853         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5854         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5855         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5856         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5857         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5858         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5859         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5860         { } /* end */
5861 };
5862
5863 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5864  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5865  */
5866 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5867         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5868         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5869         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5870         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5871         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5872         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5873         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5874         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5875         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5876         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5877         { } /* end */
5878 };
5879
5880 /*
5881  * initialization verbs
5882  */
5883 static struct hda_verb alc260_init_verbs[] = {
5884         /* Line In pin widget for input */
5885         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5886         /* CD pin widget for input */
5887         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5888         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5889         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5890         /* Mic2 (front panel) pin widget for input and vref at 80% */
5891         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5892         /* LINE-2 is used for line-out in rear */
5893         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5894         /* select line-out */
5895         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5896         /* LINE-OUT pin */
5897         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5898         /* enable HP */
5899         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5900         /* enable Mono */
5901         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5902         /* mute capture amp left and right */
5903         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5904         /* set connection select to line in (default select for this ADC) */
5905         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5906         /* mute capture amp left and right */
5907         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5908         /* set connection select to line in (default select for this ADC) */
5909         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5910         /* set vol=0 Line-Out mixer amp left and right */
5911         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5912         /* unmute pin widget amp left and right (no gain on this amp) */
5913         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5914         /* set vol=0 HP mixer amp left and right */
5915         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5916         /* unmute pin widget amp left and right (no gain on this amp) */
5917         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5918         /* set vol=0 Mono mixer amp left and right */
5919         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5920         /* unmute pin widget amp left and right (no gain on this amp) */
5921         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5922         /* unmute LINE-2 out pin */
5923         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5924         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5925          * Line In 2 = 0x03
5926          */
5927         /* mute analog inputs */
5928         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5929         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5930         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5931         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5932         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5933         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5934         /* mute Front out path */
5935         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5936         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5937         /* mute Headphone out path */
5938         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5939         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5940         /* mute Mono out path */
5941         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5942         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5943         { }
5944 };
5945
5946 #if 0 /* should be identical with alc260_init_verbs? */
5947 static struct hda_verb alc260_hp_init_verbs[] = {
5948         /* Headphone and output */
5949         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5950         /* mono output */
5951         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5952         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5953         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5954         /* Mic2 (front panel) pin widget for input and vref at 80% */
5955         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5956         /* Line In pin widget for input */
5957         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5958         /* Line-2 pin widget for output */
5959         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5960         /* CD pin widget for input */
5961         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5962         /* unmute amp left and right */
5963         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5964         /* set connection select to line in (default select for this ADC) */
5965         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5966         /* unmute Line-Out mixer amp left and right (volume = 0) */
5967         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5968         /* mute pin widget amp left and right (no gain on this amp) */
5969         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5970         /* unmute HP mixer amp left and right (volume = 0) */
5971         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5972         /* mute pin widget amp left and right (no gain on this amp) */
5973         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5974         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5975          * Line In 2 = 0x03
5976          */
5977         /* mute analog inputs */
5978         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5979         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5980         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5981         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5982         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5983         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5984         /* Unmute Front out path */
5985         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5986         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5987         /* Unmute Headphone out path */
5988         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5989         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5990         /* Unmute Mono out path */
5991         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5992         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5993         { }
5994 };
5995 #endif
5996
5997 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5998         /* Line out and output */
5999         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6000         /* mono output */
6001         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
6002         /* Mic1 (rear panel) pin widget for input and vref at 80% */
6003         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6004         /* Mic2 (front panel) pin widget for input and vref at 80% */
6005         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
6006         /* Line In pin widget for input */
6007         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6008         /* Headphone pin widget for output */
6009         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
6010         /* CD pin widget for input */
6011         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
6012         /* unmute amp left and right */
6013         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
6014         /* set connection select to line in (default select for this ADC) */
6015         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
6016         /* unmute Line-Out mixer amp left and right (volume = 0) */
6017         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6018         /* mute pin widget amp left and right (no gain on this amp) */
6019         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6020         /* unmute HP mixer amp left and right (volume = 0) */
6021         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
6022         /* mute pin widget amp left and right (no gain on this amp) */
6023         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
6024         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
6025          * Line In 2 = 0x03
6026          */
6027         /* mute analog inputs */
6028         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6029         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6030         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6031         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6032         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6033         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
6034         /* Unmute Front out path */
6035         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6036         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6037         /* Unmute Headphone out path */
6038         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6039         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6040         /* Unmute Mono out path */
6041         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
6042         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
6043         { }
6044 };
6045
6046 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
6047  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
6048  * audio = 0x16, internal speaker = 0x10.
6049  */
6050 static struct hda_verb alc260_fujitsu_init_verbs[] = {
6051         /* Disable all GPIOs */
6052         {0x01, AC_VERB_SET_GPIO_MASK, 0},
6053         /* Internal speaker is connected to headphone pin */
6054         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6055         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
6056         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6057         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
6058         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6059         /* Ensure all other unused pins are disabled and muted. */
6060         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6061         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6062         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6063         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6064         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6065         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6066         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6067         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6068
6069         /* Disable digital (SPDIF) pins */
6070         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6071         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6072
6073         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
6074          * when acting as an output.
6075          */
6076         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6077
6078         /* Start with output sum widgets muted and their output gains at min */
6079         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6080         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6081         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6082         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6083         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6084         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6085         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6086         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6087         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6088
6089         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
6090         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6091         /* Unmute Line1 pin widget output buffer since it starts as an output.
6092          * If the pin mode is changed by the user the pin mode control will
6093          * take care of enabling the pin's input/output buffers as needed.
6094          * Therefore there's no need to enable the input buffer at this
6095          * stage.
6096          */
6097         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6098         /* Unmute input buffer of pin widget used for Line-in (no equiv
6099          * mixer ctrl)
6100          */
6101         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6102
6103         /* Mute capture amp left and right */
6104         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6105         /* Set ADC connection select to match default mixer setting - line
6106          * in (on mic1 pin)
6107          */
6108         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6109
6110         /* Do the same for the second ADC: mute capture input amp and
6111          * set ADC connection to line in (on mic1 pin)
6112          */
6113         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6114         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6115
6116         /* Mute all inputs to mixer widget (even unconnected ones) */
6117         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6118         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6119         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6120         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6121         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6122         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6123         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6124         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6125
6126         { }
6127 };
6128
6129 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
6130  * similar laptops (adapted from Fujitsu init verbs).
6131  */
6132 static struct hda_verb alc260_acer_init_verbs[] = {
6133         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
6134          * the headphone jack.  Turn this on and rely on the standard mute
6135          * methods whenever the user wants to turn these outputs off.
6136          */
6137         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6138         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6139         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6140         /* Internal speaker/Headphone jack is connected to Line-out pin */
6141         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6142         /* Internal microphone/Mic jack is connected to Mic1 pin */
6143         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6144         /* Line In jack is connected to Line1 pin */
6145         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6146         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
6147         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6148         /* Ensure all other unused pins are disabled and muted. */
6149         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6150         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6151         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6152         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6153         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6154         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6155         /* Disable digital (SPDIF) pins */
6156         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6157         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6158
6159         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6160          * bus when acting as outputs.
6161          */
6162         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6163         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6164
6165         /* Start with output sum widgets muted and their output gains at min */
6166         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6167         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6168         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6169         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6170         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6171         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6172         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6173         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6174         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6175
6176         /* Unmute Line-out pin widget amp left and right
6177          * (no equiv mixer ctrl)
6178          */
6179         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6180         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
6181         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6182         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6183          * inputs. If the pin mode is changed by the user the pin mode control
6184          * will take care of enabling the pin's input/output buffers as needed.
6185          * Therefore there's no need to enable the input buffer at this
6186          * stage.
6187          */
6188         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6189         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6190
6191         /* Mute capture amp left and right */
6192         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6193         /* Set ADC connection select to match default mixer setting - mic
6194          * (on mic1 pin)
6195          */
6196         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6197
6198         /* Do similar with the second ADC: mute capture input amp and
6199          * set ADC connection to mic to match ALSA's default state.
6200          */
6201         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6202         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6203
6204         /* Mute all inputs to mixer widget (even unconnected ones) */
6205         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6206         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6207         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6208         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6209         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6210         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6211         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6212         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6213
6214         { }
6215 };
6216
6217 /* Initialisation sequence for Maxdata Favorit 100XS
6218  * (adapted from Acer init verbs).
6219  */
6220 static struct hda_verb alc260_favorit100_init_verbs[] = {
6221         /* GPIO 0 enables the output jack.
6222          * Turn this on and rely on the standard mute
6223          * methods whenever the user wants to turn these outputs off.
6224          */
6225         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6226         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6227         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
6228         /* Line/Mic input jack is connected to Mic1 pin */
6229         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
6230         /* Ensure all other unused pins are disabled and muted. */
6231         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6232         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6233         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6234         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6235         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6236         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6237         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6238         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6239         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
6240         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6241         /* Disable digital (SPDIF) pins */
6242         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6243         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6244
6245         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
6246          * bus when acting as outputs.
6247          */
6248         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6249         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6250
6251         /* Start with output sum widgets muted and their output gains at min */
6252         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6253         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6254         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6255         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6256         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6257         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6258         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6259         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6260         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6261
6262         /* Unmute Line-out pin widget amp left and right
6263          * (no equiv mixer ctrl)
6264          */
6265         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6266         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
6267          * inputs. If the pin mode is changed by the user the pin mode control
6268          * will take care of enabling the pin's input/output buffers as needed.
6269          * Therefore there's no need to enable the input buffer at this
6270          * stage.
6271          */
6272         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6273
6274         /* Mute capture amp left and right */
6275         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6276         /* Set ADC connection select to match default mixer setting - mic
6277          * (on mic1 pin)
6278          */
6279         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6280
6281         /* Do similar with the second ADC: mute capture input amp and
6282          * set ADC connection to mic to match ALSA's default state.
6283          */
6284         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6285         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6286
6287         /* Mute all inputs to mixer widget (even unconnected ones) */
6288         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6289         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6290         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6291         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6292         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6293         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6294         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6295         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6296
6297         { }
6298 };
6299
6300 static struct hda_verb alc260_will_verbs[] = {
6301         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6302         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6303         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6304         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6305         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6306         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6307         {}
6308 };
6309
6310 static struct hda_verb alc260_replacer_672v_verbs[] = {
6311         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6312         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6313         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6314
6315         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6316         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6317         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6318
6319         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6320         {}
6321 };
6322
6323 /* toggle speaker-output according to the hp-jack state */
6324 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6325 {
6326         unsigned int present;
6327
6328         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6329         present = snd_hda_jack_detect(codec, 0x0f);
6330         if (present) {
6331                 snd_hda_codec_write_cache(codec, 0x01, 0,
6332                                           AC_VERB_SET_GPIO_DATA, 1);
6333                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6334                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6335                                           PIN_HP);
6336         } else {
6337                 snd_hda_codec_write_cache(codec, 0x01, 0,
6338                                           AC_VERB_SET_GPIO_DATA, 0);
6339                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6340                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6341                                           PIN_OUT);
6342         }
6343 }
6344
6345 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6346                                        unsigned int res)
6347 {
6348         if ((res >> 26) == ALC880_HP_EVENT)
6349                 alc260_replacer_672v_automute(codec);
6350 }
6351
6352 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6353         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6354         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6355         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6356         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6357         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6358         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6359         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6360         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6361         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6362         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6363         {}
6364 };
6365
6366 /* Test configuration for debugging, modelled after the ALC880 test
6367  * configuration.
6368  */
6369 #ifdef CONFIG_SND_DEBUG
6370 static hda_nid_t alc260_test_dac_nids[1] = {
6371         0x02,
6372 };
6373 static hda_nid_t alc260_test_adc_nids[2] = {
6374         0x04, 0x05,
6375 };
6376 /* For testing the ALC260, each input MUX needs its own definition since
6377  * the signal assignments are different.  This assumes that the first ADC
6378  * is NID 0x04.
6379  */
6380 static struct hda_input_mux alc260_test_capture_sources[2] = {
6381         {
6382                 .num_items = 7,
6383                 .items = {
6384                         { "MIC1 pin", 0x0 },
6385                         { "MIC2 pin", 0x1 },
6386                         { "LINE1 pin", 0x2 },
6387                         { "LINE2 pin", 0x3 },
6388                         { "CD pin", 0x4 },
6389                         { "LINE-OUT pin", 0x5 },
6390                         { "HP-OUT pin", 0x6 },
6391                 },
6392         },
6393         {
6394                 .num_items = 8,
6395                 .items = {
6396                         { "MIC1 pin", 0x0 },
6397                         { "MIC2 pin", 0x1 },
6398                         { "LINE1 pin", 0x2 },
6399                         { "LINE2 pin", 0x3 },
6400                         { "CD pin", 0x4 },
6401                         { "Mixer", 0x5 },
6402                         { "LINE-OUT pin", 0x6 },
6403                         { "HP-OUT pin", 0x7 },
6404                 },
6405         },
6406 };
6407 static struct snd_kcontrol_new alc260_test_mixer[] = {
6408         /* Output driver widgets */
6409         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6410         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6411         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6412         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6413         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6414         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6415
6416         /* Modes for retasking pin widgets
6417          * Note: the ALC260 doesn't seem to act on requests to enable mic
6418          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6419          * mention this restriction.  At this stage it's not clear whether
6420          * this behaviour is intentional or is a hardware bug in chip
6421          * revisions available at least up until early 2006.  Therefore for
6422          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6423          * choices, but if it turns out that the lack of mic bias for these
6424          * NIDs is intentional we could change their modes from
6425          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6426          */
6427         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6428         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6429         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6430         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6431         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6432         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6433
6434         /* Loopback mixer controls */
6435         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6436         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6437         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6438         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6439         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6440         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6441         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6442         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6443         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6444         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6445         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6446         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6447         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6448         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6449
6450         /* Controls for GPIO pins, assuming they are configured as outputs */
6451         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6452         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6453         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6454         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6455
6456         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6457          * is ambigious as to which NID is which; testing on laptops which
6458          * make this output available should provide clarification.
6459          */
6460         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6461         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6462
6463         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6464          * this output to turn on an external amplifier.
6465          */
6466         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6467         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6468
6469         { } /* end */
6470 };
6471 static struct hda_verb alc260_test_init_verbs[] = {
6472         /* Enable all GPIOs as outputs with an initial value of 0 */
6473         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6474         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6475         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6476
6477         /* Enable retasking pins as output, initially without power amp */
6478         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6479         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6480         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6481         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6482         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6483         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6484
6485         /* Disable digital (SPDIF) pins initially, but users can enable
6486          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6487          * payload also sets the generation to 0, output to be in "consumer"
6488          * PCM format, copyright asserted, no pre-emphasis and no validity
6489          * control.
6490          */
6491         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6492         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6493
6494         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6495          * OUT1 sum bus when acting as an output.
6496          */
6497         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6498         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6499         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6500         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6501
6502         /* Start with output sum widgets muted and their output gains at min */
6503         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6504         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6505         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6506         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6507         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6509         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6510         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6511         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6512
6513         /* Unmute retasking pin widget output buffers since the default
6514          * state appears to be output.  As the pin mode is changed by the
6515          * user the pin mode control will take care of enabling the pin's
6516          * input/output buffers as needed.
6517          */
6518         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6519         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6520         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6521         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6522         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6523         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6524         /* Also unmute the mono-out pin widget */
6525         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6526
6527         /* Mute capture amp left and right */
6528         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6529         /* Set ADC connection select to match default mixer setting (mic1
6530          * pin)
6531          */
6532         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6533
6534         /* Do the same for the second ADC: mute capture input amp and
6535          * set ADC connection to mic1 pin
6536          */
6537         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6538         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6539
6540         /* Mute all inputs to mixer widget (even unconnected ones) */
6541         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6549
6550         { }
6551 };
6552 #endif
6553
6554 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6555 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6556
6557 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6558 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6559
6560 /*
6561  * for BIOS auto-configuration
6562  */
6563
6564 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6565                                         const char *pfx, int *vol_bits)
6566 {
6567         hda_nid_t nid_vol;
6568         unsigned long vol_val, sw_val;
6569         int err;
6570
6571         if (nid >= 0x0f && nid < 0x11) {
6572                 nid_vol = nid - 0x7;
6573                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6574                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6575         } else if (nid == 0x11) {
6576                 nid_vol = nid - 0x7;
6577                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6578                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6579         } else if (nid >= 0x12 && nid <= 0x15) {
6580                 nid_vol = 0x08;
6581                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6582                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6583         } else
6584                 return 0; /* N/A */
6585
6586         if (!(*vol_bits & (1 << nid_vol))) {
6587                 /* first control for the volume widget */
6588                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6589                 if (err < 0)
6590                         return err;
6591                 *vol_bits |= (1 << nid_vol);
6592         }
6593         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6594         if (err < 0)
6595                 return err;
6596         return 1;
6597 }
6598
6599 /* add playback controls from the parsed DAC table */
6600 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6601                                              const struct auto_pin_cfg *cfg)
6602 {
6603         hda_nid_t nid;
6604         int err;
6605         int vols = 0;
6606
6607         spec->multiout.num_dacs = 1;
6608         spec->multiout.dac_nids = spec->private_dac_nids;
6609         spec->multiout.dac_nids[0] = 0x02;
6610
6611         nid = cfg->line_out_pins[0];
6612         if (nid) {
6613                 const char *pfx;
6614                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6615                         pfx = "Master";
6616                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6617                         pfx = "Speaker";
6618                 else
6619                         pfx = "Front";
6620                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6621                 if (err < 0)
6622                         return err;
6623         }
6624
6625         nid = cfg->speaker_pins[0];
6626         if (nid) {
6627                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6628                 if (err < 0)
6629                         return err;
6630         }
6631
6632         nid = cfg->hp_pins[0];
6633         if (nid) {
6634                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6635                                                    &vols);
6636                 if (err < 0)
6637                         return err;
6638         }
6639         return 0;
6640 }
6641
6642 /* create playback/capture controls for input pins */
6643 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6644                                                 const struct auto_pin_cfg *cfg)
6645 {
6646         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6647 }
6648
6649 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6650                                               hda_nid_t nid, int pin_type,
6651                                               int sel_idx)
6652 {
6653         alc_set_pin_output(codec, nid, pin_type);
6654         /* need the manual connection? */
6655         if (nid >= 0x12) {
6656                 int idx = nid - 0x12;
6657                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6658                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6659         }
6660 }
6661
6662 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6663 {
6664         struct alc_spec *spec = codec->spec;
6665         hda_nid_t nid;
6666
6667         nid = spec->autocfg.line_out_pins[0];
6668         if (nid) {
6669                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6670                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6671         }
6672
6673         nid = spec->autocfg.speaker_pins[0];
6674         if (nid)
6675                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6676
6677         nid = spec->autocfg.hp_pins[0];
6678         if (nid)
6679                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6680 }
6681
6682 #define ALC260_PIN_CD_NID               0x16
6683 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6684 {
6685         struct alc_spec *spec = codec->spec;
6686         struct auto_pin_cfg *cfg = &spec->autocfg;
6687         int i;
6688
6689         for (i = 0; i < cfg->num_inputs; i++) {
6690                 hda_nid_t nid = cfg->inputs[i].pin;
6691                 if (nid >= 0x12) {
6692                         alc_set_input_pin(codec, nid, i);
6693                         if (nid != ALC260_PIN_CD_NID &&
6694                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6695                                 snd_hda_codec_write(codec, nid, 0,
6696                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6697                                                     AMP_OUT_MUTE);
6698                 }
6699         }
6700 }
6701
6702 #define alc260_auto_init_input_src      alc880_auto_init_input_src
6703
6704 /*
6705  * generic initialization of ADC, input mixers and output mixers
6706  */
6707 static struct hda_verb alc260_volume_init_verbs[] = {
6708         /*
6709          * Unmute ADC0-1 and set the default input to mic-in
6710          */
6711         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6712         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6713         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6714         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6715
6716         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6717          * mixer widget
6718          * Note: PASD motherboards uses the Line In 2 as the input for
6719          * front panel mic (mic 2)
6720          */
6721         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6722         /* mute analog inputs */
6723         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6724         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6725         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6727         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6728
6729         /*
6730          * Set up output mixers (0x08 - 0x0a)
6731          */
6732         /* set vol=0 to output mixers */
6733         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6734         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6735         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6736         /* set up input amps for analog loopback */
6737         /* Amp Indices: DAC = 0, mixer = 1 */
6738         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6739         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6740         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6741         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6742         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6743         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6744
6745         { }
6746 };
6747
6748 static int alc260_parse_auto_config(struct hda_codec *codec)
6749 {
6750         struct alc_spec *spec = codec->spec;
6751         int err;
6752         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6753
6754         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6755                                            alc260_ignore);
6756         if (err < 0)
6757                 return err;
6758         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6759         if (err < 0)
6760                 return err;
6761         if (!spec->kctls.list)
6762                 return 0; /* can't find valid BIOS pin config */
6763         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6764         if (err < 0)
6765                 return err;
6766
6767         spec->multiout.max_channels = 2;
6768
6769         if (spec->autocfg.dig_outs)
6770                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6771         if (spec->kctls.list)
6772                 add_mixer(spec, spec->kctls.list);
6773
6774         add_verb(spec, alc260_volume_init_verbs);
6775
6776         spec->num_mux_defs = 1;
6777         spec->input_mux = &spec->private_imux[0];
6778
6779         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6780
6781         return 1;
6782 }
6783
6784 /* additional initialization for auto-configuration model */
6785 static void alc260_auto_init(struct hda_codec *codec)
6786 {
6787         struct alc_spec *spec = codec->spec;
6788         alc260_auto_init_multi_out(codec);
6789         alc260_auto_init_analog_input(codec);
6790         alc260_auto_init_input_src(codec);
6791         alc_auto_init_digital(codec);
6792         if (spec->unsol_event)
6793                 alc_inithook(codec);
6794 }
6795
6796 #ifdef CONFIG_SND_HDA_POWER_SAVE
6797 static struct hda_amp_list alc260_loopbacks[] = {
6798         { 0x07, HDA_INPUT, 0 },
6799         { 0x07, HDA_INPUT, 1 },
6800         { 0x07, HDA_INPUT, 2 },
6801         { 0x07, HDA_INPUT, 3 },
6802         { 0x07, HDA_INPUT, 4 },
6803         { } /* end */
6804 };
6805 #endif
6806
6807 /*
6808  * Pin config fixes
6809  */
6810 enum {
6811         PINFIX_HP_DC5750,
6812 };
6813
6814 static const struct alc_fixup alc260_fixups[] = {
6815         [PINFIX_HP_DC5750] = {
6816                 .pins = (const struct alc_pincfg[]) {
6817                         { 0x11, 0x90130110 }, /* speaker */
6818                         { }
6819                 }
6820         },
6821 };
6822
6823 static struct snd_pci_quirk alc260_fixup_tbl[] = {
6824         SND_PCI_QUIRK(0x103c, 0x280a, "HP dc5750", PINFIX_HP_DC5750),
6825         {}
6826 };
6827
6828 /*
6829  * ALC260 configurations
6830  */
6831 static const char *alc260_models[ALC260_MODEL_LAST] = {
6832         [ALC260_BASIC]          = "basic",
6833         [ALC260_HP]             = "hp",
6834         [ALC260_HP_3013]        = "hp-3013",
6835         [ALC260_HP_DC7600]      = "hp-dc7600",
6836         [ALC260_FUJITSU_S702X]  = "fujitsu",
6837         [ALC260_ACER]           = "acer",
6838         [ALC260_WILL]           = "will",
6839         [ALC260_REPLACER_672V]  = "replacer",
6840         [ALC260_FAVORIT100]     = "favorit100",
6841 #ifdef CONFIG_SND_DEBUG
6842         [ALC260_TEST]           = "test",
6843 #endif
6844         [ALC260_AUTO]           = "auto",
6845 };
6846
6847 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6848         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6849         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6850         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6851         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6852         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6853         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6854         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6855         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6856         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6857         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6858         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6859         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6860         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6861         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6862         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6863         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6864         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6865         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6866         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6867         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6868         {}
6869 };
6870
6871 static struct alc_config_preset alc260_presets[] = {
6872         [ALC260_BASIC] = {
6873                 .mixers = { alc260_base_output_mixer,
6874                             alc260_input_mixer },
6875                 .init_verbs = { alc260_init_verbs },
6876                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6877                 .dac_nids = alc260_dac_nids,
6878                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6879                 .adc_nids = alc260_dual_adc_nids,
6880                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6881                 .channel_mode = alc260_modes,
6882                 .input_mux = &alc260_capture_source,
6883         },
6884         [ALC260_HP] = {
6885                 .mixers = { alc260_hp_output_mixer,
6886                             alc260_input_mixer },
6887                 .init_verbs = { alc260_init_verbs,
6888                                 alc260_hp_unsol_verbs },
6889                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6890                 .dac_nids = alc260_dac_nids,
6891                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6892                 .adc_nids = alc260_adc_nids_alt,
6893                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6894                 .channel_mode = alc260_modes,
6895                 .input_mux = &alc260_capture_source,
6896                 .unsol_event = alc260_hp_unsol_event,
6897                 .init_hook = alc260_hp_automute,
6898         },
6899         [ALC260_HP_DC7600] = {
6900                 .mixers = { alc260_hp_dc7600_mixer,
6901                             alc260_input_mixer },
6902                 .init_verbs = { alc260_init_verbs,
6903                                 alc260_hp_dc7600_verbs },
6904                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6905                 .dac_nids = alc260_dac_nids,
6906                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6907                 .adc_nids = alc260_adc_nids_alt,
6908                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6909                 .channel_mode = alc260_modes,
6910                 .input_mux = &alc260_capture_source,
6911                 .unsol_event = alc260_hp_3012_unsol_event,
6912                 .init_hook = alc260_hp_3012_automute,
6913         },
6914         [ALC260_HP_3013] = {
6915                 .mixers = { alc260_hp_3013_mixer,
6916                             alc260_input_mixer },
6917                 .init_verbs = { alc260_hp_3013_init_verbs,
6918                                 alc260_hp_3013_unsol_verbs },
6919                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6920                 .dac_nids = alc260_dac_nids,
6921                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6922                 .adc_nids = alc260_adc_nids_alt,
6923                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6924                 .channel_mode = alc260_modes,
6925                 .input_mux = &alc260_capture_source,
6926                 .unsol_event = alc260_hp_3013_unsol_event,
6927                 .init_hook = alc260_hp_3013_automute,
6928         },
6929         [ALC260_FUJITSU_S702X] = {
6930                 .mixers = { alc260_fujitsu_mixer },
6931                 .init_verbs = { alc260_fujitsu_init_verbs },
6932                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6933                 .dac_nids = alc260_dac_nids,
6934                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6935                 .adc_nids = alc260_dual_adc_nids,
6936                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6937                 .channel_mode = alc260_modes,
6938                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6939                 .input_mux = alc260_fujitsu_capture_sources,
6940         },
6941         [ALC260_ACER] = {
6942                 .mixers = { alc260_acer_mixer },
6943                 .init_verbs = { alc260_acer_init_verbs },
6944                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6945                 .dac_nids = alc260_dac_nids,
6946                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6947                 .adc_nids = alc260_dual_adc_nids,
6948                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6949                 .channel_mode = alc260_modes,
6950                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6951                 .input_mux = alc260_acer_capture_sources,
6952         },
6953         [ALC260_FAVORIT100] = {
6954                 .mixers = { alc260_favorit100_mixer },
6955                 .init_verbs = { alc260_favorit100_init_verbs },
6956                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6957                 .dac_nids = alc260_dac_nids,
6958                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6959                 .adc_nids = alc260_dual_adc_nids,
6960                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6961                 .channel_mode = alc260_modes,
6962                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6963                 .input_mux = alc260_favorit100_capture_sources,
6964         },
6965         [ALC260_WILL] = {
6966                 .mixers = { alc260_will_mixer },
6967                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6968                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6969                 .dac_nids = alc260_dac_nids,
6970                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6971                 .adc_nids = alc260_adc_nids,
6972                 .dig_out_nid = ALC260_DIGOUT_NID,
6973                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6974                 .channel_mode = alc260_modes,
6975                 .input_mux = &alc260_capture_source,
6976         },
6977         [ALC260_REPLACER_672V] = {
6978                 .mixers = { alc260_replacer_672v_mixer },
6979                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6980                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6981                 .dac_nids = alc260_dac_nids,
6982                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6983                 .adc_nids = alc260_adc_nids,
6984                 .dig_out_nid = ALC260_DIGOUT_NID,
6985                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6986                 .channel_mode = alc260_modes,
6987                 .input_mux = &alc260_capture_source,
6988                 .unsol_event = alc260_replacer_672v_unsol_event,
6989                 .init_hook = alc260_replacer_672v_automute,
6990         },
6991 #ifdef CONFIG_SND_DEBUG
6992         [ALC260_TEST] = {
6993                 .mixers = { alc260_test_mixer },
6994                 .init_verbs = { alc260_test_init_verbs },
6995                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6996                 .dac_nids = alc260_test_dac_nids,
6997                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6998                 .adc_nids = alc260_test_adc_nids,
6999                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
7000                 .channel_mode = alc260_modes,
7001                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
7002                 .input_mux = alc260_test_capture_sources,
7003         },
7004 #endif
7005 };
7006
7007 static int patch_alc260(struct hda_codec *codec)
7008 {
7009         struct alc_spec *spec;
7010         int err, board_config;
7011
7012         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
7013         if (spec == NULL)
7014                 return -ENOMEM;
7015
7016         codec->spec = spec;
7017
7018         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
7019                                                   alc260_models,
7020                                                   alc260_cfg_tbl);
7021         if (board_config < 0) {
7022                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
7023                            codec->chip_name);
7024                 board_config = ALC260_AUTO;
7025         }
7026
7027         if (board_config == ALC260_AUTO)
7028                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 1);
7029
7030         if (board_config == ALC260_AUTO) {
7031                 /* automatic parse from the BIOS config */
7032                 err = alc260_parse_auto_config(codec);
7033                 if (err < 0) {
7034                         alc_free(codec);
7035                         return err;
7036                 } else if (!err) {
7037                         printk(KERN_INFO
7038                                "hda_codec: Cannot set up configuration "
7039                                "from BIOS.  Using base mode...\n");
7040                         board_config = ALC260_BASIC;
7041                 }
7042         }
7043
7044         err = snd_hda_attach_beep_device(codec, 0x1);
7045         if (err < 0) {
7046                 alc_free(codec);
7047                 return err;
7048         }
7049
7050         if (board_config != ALC260_AUTO)
7051                 setup_preset(codec, &alc260_presets[board_config]);
7052
7053         spec->stream_analog_playback = &alc260_pcm_analog_playback;
7054         spec->stream_analog_capture = &alc260_pcm_analog_capture;
7055         spec->stream_analog_alt_capture = &alc260_pcm_analog_capture;
7056
7057         spec->stream_digital_playback = &alc260_pcm_digital_playback;
7058         spec->stream_digital_capture = &alc260_pcm_digital_capture;
7059
7060         if (!spec->adc_nids && spec->input_mux) {
7061                 /* check whether NID 0x04 is valid */
7062                 unsigned int wcap = get_wcaps(codec, 0x04);
7063                 wcap = get_wcaps_type(wcap);
7064                 /* get type */
7065                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
7066                         spec->adc_nids = alc260_adc_nids_alt;
7067                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
7068                 } else {
7069                         spec->adc_nids = alc260_adc_nids;
7070                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
7071                 }
7072         }
7073         set_capture_mixer(codec);
7074         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
7075
7076         if (board_config == ALC260_AUTO)
7077                 alc_pick_fixup(codec, alc260_fixup_tbl, alc260_fixups, 0);
7078
7079         spec->vmaster_nid = 0x08;
7080
7081         codec->patch_ops = alc_patch_ops;
7082         if (board_config == ALC260_AUTO)
7083                 spec->init_hook = alc260_auto_init;
7084 #ifdef CONFIG_SND_HDA_POWER_SAVE
7085         if (!spec->loopback.amplist)
7086                 spec->loopback.amplist = alc260_loopbacks;
7087 #endif
7088
7089         return 0;
7090 }
7091
7092
7093 /*
7094  * ALC882/883/885/888/889 support
7095  *
7096  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
7097  * configuration.  Each pin widget can choose any input DACs and a mixer.
7098  * Each ADC is connected from a mixer of all inputs.  This makes possible
7099  * 6-channel independent captures.
7100  *
7101  * In addition, an independent DAC for the multi-playback (not used in this
7102  * driver yet).
7103  */
7104 #define ALC882_DIGOUT_NID       0x06
7105 #define ALC882_DIGIN_NID        0x0a
7106 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
7107 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
7108 #define ALC1200_DIGOUT_NID      0x10
7109
7110
7111 static struct hda_channel_mode alc882_ch_modes[1] = {
7112         { 8, NULL }
7113 };
7114
7115 /* DACs */
7116 static hda_nid_t alc882_dac_nids[4] = {
7117         /* front, rear, clfe, rear_surr */
7118         0x02, 0x03, 0x04, 0x05
7119 };
7120 #define alc883_dac_nids         alc882_dac_nids
7121
7122 /* ADCs */
7123 #define alc882_adc_nids         alc880_adc_nids
7124 #define alc882_adc_nids_alt     alc880_adc_nids_alt
7125 #define alc883_adc_nids         alc882_adc_nids_alt
7126 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
7127 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
7128 #define alc889_adc_nids         alc880_adc_nids
7129
7130 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
7131 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
7132 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
7133 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
7134 #define alc889_capsrc_nids      alc882_capsrc_nids
7135
7136 /* input MUX */
7137 /* FIXME: should be a matrix-type input source selection */
7138
7139 static struct hda_input_mux alc882_capture_source = {
7140         .num_items = 4,
7141         .items = {
7142                 { "Mic", 0x0 },
7143                 { "Front Mic", 0x1 },
7144                 { "Line", 0x2 },
7145                 { "CD", 0x4 },
7146         },
7147 };
7148
7149 #define alc883_capture_source   alc882_capture_source
7150
7151 static struct hda_input_mux alc889_capture_source = {
7152         .num_items = 3,
7153         .items = {
7154                 { "Front Mic", 0x0 },
7155                 { "Mic", 0x3 },
7156                 { "Line", 0x2 },
7157         },
7158 };
7159
7160 static struct hda_input_mux mb5_capture_source = {
7161         .num_items = 3,
7162         .items = {
7163                 { "Mic", 0x1 },
7164                 { "Line", 0x7 },
7165                 { "CD", 0x4 },
7166         },
7167 };
7168
7169 static struct hda_input_mux macmini3_capture_source = {
7170         .num_items = 2,
7171         .items = {
7172                 { "Line", 0x2 },
7173                 { "CD", 0x4 },
7174         },
7175 };
7176
7177 static struct hda_input_mux alc883_3stack_6ch_intel = {
7178         .num_items = 4,
7179         .items = {
7180                 { "Mic", 0x1 },
7181                 { "Front Mic", 0x0 },
7182                 { "Line", 0x2 },
7183                 { "CD", 0x4 },
7184         },
7185 };
7186
7187 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
7188         .num_items = 2,
7189         .items = {
7190                 { "Mic", 0x1 },
7191                 { "Line", 0x2 },
7192         },
7193 };
7194
7195 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
7196         .num_items = 4,
7197         .items = {
7198                 { "Mic", 0x0 },
7199                 { "Int Mic", 0x1 },
7200                 { "Line", 0x2 },
7201                 { "CD", 0x4 },
7202         },
7203 };
7204
7205 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
7206         .num_items = 2,
7207         .items = {
7208                 { "Mic", 0x0 },
7209                 { "Int Mic", 0x1 },
7210         },
7211 };
7212
7213 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
7214         .num_items = 3,
7215         .items = {
7216                 { "Mic", 0x0 },
7217                 { "Front Mic", 0x1 },
7218                 { "Line", 0x4 },
7219         },
7220 };
7221
7222 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
7223         .num_items = 2,
7224         .items = {
7225                 { "Mic", 0x0 },
7226                 { "Line", 0x2 },
7227         },
7228 };
7229
7230 static struct hda_input_mux alc889A_mb31_capture_source = {
7231         .num_items = 2,
7232         .items = {
7233                 { "Mic", 0x0 },
7234                 /* Front Mic (0x01) unused */
7235                 { "Line", 0x2 },
7236                 /* Line 2 (0x03) unused */
7237                 /* CD (0x04) unused? */
7238         },
7239 };
7240
7241 static struct hda_input_mux alc889A_imac91_capture_source = {
7242         .num_items = 2,
7243         .items = {
7244                 { "Mic", 0x01 },
7245                 { "Line", 0x2 }, /* Not sure! */
7246         },
7247 };
7248
7249 /*
7250  * 2ch mode
7251  */
7252 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
7253         { 2, NULL }
7254 };
7255
7256 /*
7257  * 2ch mode
7258  */
7259 static struct hda_verb alc882_3ST_ch2_init[] = {
7260         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7261         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7262         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7263         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7264         { } /* end */
7265 };
7266
7267 /*
7268  * 4ch mode
7269  */
7270 static struct hda_verb alc882_3ST_ch4_init[] = {
7271         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7272         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7273         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7274         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7275         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7276         { } /* end */
7277 };
7278
7279 /*
7280  * 6ch mode
7281  */
7282 static struct hda_verb alc882_3ST_ch6_init[] = {
7283         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7284         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7285         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7286         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7287         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7288         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7289         { } /* end */
7290 };
7291
7292 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
7293         { 2, alc882_3ST_ch2_init },
7294         { 4, alc882_3ST_ch4_init },
7295         { 6, alc882_3ST_ch6_init },
7296 };
7297
7298 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
7299
7300 /*
7301  * 2ch mode
7302  */
7303 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
7304         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
7305         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7306         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7307         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7308         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7309         { } /* end */
7310 };
7311
7312 /*
7313  * 4ch mode
7314  */
7315 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
7316         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7317         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7318         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7319         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7320         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7321         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7322         { } /* end */
7323 };
7324
7325 /*
7326  * 6ch mode
7327  */
7328 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
7329         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7330         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7331         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7332         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7333         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7334         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7335         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7336         { } /* end */
7337 };
7338
7339 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
7340         { 2, alc883_3ST_ch2_clevo_init },
7341         { 4, alc883_3ST_ch4_clevo_init },
7342         { 6, alc883_3ST_ch6_clevo_init },
7343 };
7344
7345
7346 /*
7347  * 6ch mode
7348  */
7349 static struct hda_verb alc882_sixstack_ch6_init[] = {
7350         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7351         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7352         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7353         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7354         { } /* end */
7355 };
7356
7357 /*
7358  * 8ch mode
7359  */
7360 static struct hda_verb alc882_sixstack_ch8_init[] = {
7361         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7362         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7363         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7364         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7365         { } /* end */
7366 };
7367
7368 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7369         { 6, alc882_sixstack_ch6_init },
7370         { 8, alc882_sixstack_ch8_init },
7371 };
7372
7373
7374 /* Macbook Air 2,1 */
7375
7376 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7377       { 2, NULL },
7378 };
7379
7380 /*
7381  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7382  */
7383
7384 /*
7385  * 2ch mode
7386  */
7387 static struct hda_verb alc885_mbp_ch2_init[] = {
7388         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7389         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7390         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7391         { } /* end */
7392 };
7393
7394 /*
7395  * 4ch mode
7396  */
7397 static struct hda_verb alc885_mbp_ch4_init[] = {
7398         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7399         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7400         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7401         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7402         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7403         { } /* end */
7404 };
7405
7406 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7407         { 2, alc885_mbp_ch2_init },
7408         { 4, alc885_mbp_ch4_init },
7409 };
7410
7411 /*
7412  * 2ch
7413  * Speakers/Woofer/HP = Front
7414  * LineIn = Input
7415  */
7416 static struct hda_verb alc885_mb5_ch2_init[] = {
7417         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7418         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7419         { } /* end */
7420 };
7421
7422 /*
7423  * 6ch mode
7424  * Speakers/HP = Front
7425  * Woofer = LFE
7426  * LineIn = Surround
7427  */
7428 static struct hda_verb alc885_mb5_ch6_init[] = {
7429         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7430         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7431         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7432         { } /* end */
7433 };
7434
7435 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7436         { 2, alc885_mb5_ch2_init },
7437         { 6, alc885_mb5_ch6_init },
7438 };
7439
7440 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7441
7442 /*
7443  * 2ch mode
7444  */
7445 static struct hda_verb alc883_4ST_ch2_init[] = {
7446         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7447         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7448         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7449         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7450         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7451         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7452         { } /* end */
7453 };
7454
7455 /*
7456  * 4ch mode
7457  */
7458 static struct hda_verb alc883_4ST_ch4_init[] = {
7459         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7460         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7461         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7462         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7463         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7464         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7465         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7466         { } /* end */
7467 };
7468
7469 /*
7470  * 6ch mode
7471  */
7472 static struct hda_verb alc883_4ST_ch6_init[] = {
7473         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7474         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7475         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7476         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7477         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7478         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7479         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7480         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7481         { } /* end */
7482 };
7483
7484 /*
7485  * 8ch mode
7486  */
7487 static struct hda_verb alc883_4ST_ch8_init[] = {
7488         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7489         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7490         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7491         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7492         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7493         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7494         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7495         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7496         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7497         { } /* end */
7498 };
7499
7500 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7501         { 2, alc883_4ST_ch2_init },
7502         { 4, alc883_4ST_ch4_init },
7503         { 6, alc883_4ST_ch6_init },
7504         { 8, alc883_4ST_ch8_init },
7505 };
7506
7507
7508 /*
7509  * 2ch mode
7510  */
7511 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7512         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7513         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7514         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7515         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7516         { } /* end */
7517 };
7518
7519 /*
7520  * 4ch mode
7521  */
7522 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7523         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7524         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7525         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7526         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7527         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7528         { } /* end */
7529 };
7530
7531 /*
7532  * 6ch mode
7533  */
7534 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7535         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7536         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7537         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7538         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7539         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7540         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7541         { } /* end */
7542 };
7543
7544 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7545         { 2, alc883_3ST_ch2_intel_init },
7546         { 4, alc883_3ST_ch4_intel_init },
7547         { 6, alc883_3ST_ch6_intel_init },
7548 };
7549
7550 /*
7551  * 2ch mode
7552  */
7553 static struct hda_verb alc889_ch2_intel_init[] = {
7554         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7555         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7556         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7557         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7558         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7559         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7560         { } /* end */
7561 };
7562
7563 /*
7564  * 6ch mode
7565  */
7566 static struct hda_verb alc889_ch6_intel_init[] = {
7567         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7568         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7569         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7570         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7571         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7572         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7573         { } /* end */
7574 };
7575
7576 /*
7577  * 8ch mode
7578  */
7579 static struct hda_verb alc889_ch8_intel_init[] = {
7580         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7581         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7582         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7583         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7584         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7585         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7586         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7587         { } /* end */
7588 };
7589
7590 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7591         { 2, alc889_ch2_intel_init },
7592         { 6, alc889_ch6_intel_init },
7593         { 8, alc889_ch8_intel_init },
7594 };
7595
7596 /*
7597  * 6ch mode
7598  */
7599 static struct hda_verb alc883_sixstack_ch6_init[] = {
7600         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7601         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7602         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7603         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7604         { } /* end */
7605 };
7606
7607 /*
7608  * 8ch mode
7609  */
7610 static struct hda_verb alc883_sixstack_ch8_init[] = {
7611         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7612         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7613         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7614         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7615         { } /* end */
7616 };
7617
7618 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7619         { 6, alc883_sixstack_ch6_init },
7620         { 8, alc883_sixstack_ch8_init },
7621 };
7622
7623
7624 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7625  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7626  */
7627 static struct snd_kcontrol_new alc882_base_mixer[] = {
7628         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7629         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7630         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7631         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7632         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7633         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7634         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7635         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7636         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7637         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7638         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7639         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7640         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7641         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7642         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7643         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7644         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7645         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7646         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7647         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7648         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7649         { } /* end */
7650 };
7651
7652 /* Macbook Air 2,1 same control for HP and internal Speaker */
7653
7654 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7655       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7656       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7657      { }
7658 };
7659
7660
7661 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7662         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7663         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7664         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7665         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7666         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7667         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7668         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7670         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7671         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7672         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7673         { } /* end */
7674 };
7675
7676 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7677         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7678         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7679         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7680         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7681         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7682         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7683         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7684         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7685         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7686         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7687         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7688         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7689         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7690         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7691         { } /* end */
7692 };
7693
7694 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7695         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7696         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7697         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7698         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7699         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7700         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7701         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7702         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7703         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7704         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7705         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7706         { } /* end */
7707 };
7708
7709 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7710         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7711         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7712         { } /* end */
7713 };
7714
7715
7716 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7717         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7718         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7719         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7720         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7721         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7722         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7723         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7724         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7725         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7726         { } /* end */
7727 };
7728
7729 static struct snd_kcontrol_new alc882_targa_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_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7739         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7740         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7741         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7742         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7743         { } /* end */
7744 };
7745
7746 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7747  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7748  */
7749 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7750         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7751         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7752         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7753         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7754         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7755         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7756         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7757         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7758         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7759         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7760         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7761         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7762         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7763         { } /* end */
7764 };
7765
7766 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7767         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7768         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7769         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7770         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7771         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7772         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7773         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7774         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7775         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7776         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7777         { } /* end */
7778 };
7779
7780 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7781         {
7782                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7783                 .name = "Channel Mode",
7784                 .info = alc_ch_mode_info,
7785                 .get = alc_ch_mode_get,
7786                 .put = alc_ch_mode_put,
7787         },
7788         { } /* end */
7789 };
7790
7791 static struct hda_verb alc882_base_init_verbs[] = {
7792         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7793         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7794         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7795         /* Rear mixer */
7796         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7797         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7798         /* CLFE mixer */
7799         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7800         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7801         /* Side mixer */
7802         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7803         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7804
7805         /* Front Pin: output 0 (0x0c) */
7806         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7807         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7808         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7809         /* Rear Pin: output 1 (0x0d) */
7810         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7811         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7812         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7813         /* CLFE Pin: output 2 (0x0e) */
7814         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7815         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7816         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7817         /* Side Pin: output 3 (0x0f) */
7818         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7819         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7820         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7821         /* Mic (rear) pin: input vref at 80% */
7822         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7823         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7824         /* Front Mic pin: input vref at 80% */
7825         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7826         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7827         /* Line In pin: input */
7828         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7829         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7830         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7831         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7832         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7833         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7834         /* CD pin widget for input */
7835         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7836
7837         /* FIXME: use matrix-type input source selection */
7838         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7839         /* Input mixer2 */
7840         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7841         /* Input mixer3 */
7842         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7843         /* ADC2: mute amp left and right */
7844         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7845         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7846         /* ADC3: mute amp left and right */
7847         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7848         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7849
7850         { }
7851 };
7852
7853 static struct hda_verb alc882_adc1_init_verbs[] = {
7854         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7855         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7856         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7857         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7858         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7859         /* ADC1: mute amp left and right */
7860         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7861         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7862         { }
7863 };
7864
7865 static struct hda_verb alc882_eapd_verbs[] = {
7866         /* change to EAPD mode */
7867         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7868         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7869         { }
7870 };
7871
7872 static struct hda_verb alc889_eapd_verbs[] = {
7873         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7874         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7875         { }
7876 };
7877
7878 static struct hda_verb alc_hp15_unsol_verbs[] = {
7879         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7880         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7881         {}
7882 };
7883
7884 static struct hda_verb alc885_init_verbs[] = {
7885         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7886         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7887         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7888         /* Rear mixer */
7889         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7890         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7891         /* CLFE mixer */
7892         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7893         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7894         /* Side mixer */
7895         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7896         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7897
7898         /* Front HP Pin: output 0 (0x0c) */
7899         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7900         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7901         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7902         /* Front Pin: output 0 (0x0c) */
7903         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7904         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7905         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7906         /* Rear Pin: output 1 (0x0d) */
7907         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7908         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7909         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7910         /* CLFE Pin: output 2 (0x0e) */
7911         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7912         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7913         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7914         /* Side Pin: output 3 (0x0f) */
7915         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7916         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7917         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7918         /* Mic (rear) pin: input vref at 80% */
7919         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7920         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7921         /* Front Mic pin: input vref at 80% */
7922         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7923         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7924         /* Line In pin: input */
7925         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7926         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7927
7928         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7929         /* Input mixer1 */
7930         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7931         /* Input mixer2 */
7932         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7933         /* Input mixer3 */
7934         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7935         /* ADC2: mute amp left and right */
7936         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7937         /* ADC3: mute amp left and right */
7938         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7939
7940         { }
7941 };
7942
7943 static struct hda_verb alc885_init_input_verbs[] = {
7944         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7945         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7946         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7947         { }
7948 };
7949
7950
7951 /* Unmute Selector 24h and set the default input to front mic */
7952 static struct hda_verb alc889_init_input_verbs[] = {
7953         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7954         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7955         { }
7956 };
7957
7958
7959 #define alc883_init_verbs       alc882_base_init_verbs
7960
7961 /* Mac Pro test */
7962 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7963         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7964         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7965         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7966         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7967         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7968         /* FIXME: this looks suspicious...
7969         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7970         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7971         */
7972         { } /* end */
7973 };
7974
7975 static struct hda_verb alc882_macpro_init_verbs[] = {
7976         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7977         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7978         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7979         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7980         /* Front Pin: output 0 (0x0c) */
7981         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7982         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7983         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7984         /* Front Mic pin: input vref at 80% */
7985         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7986         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7987         /* Speaker:  output */
7988         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7989         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7990         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7991         /* Headphone output (output 0 - 0x0c) */
7992         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7993         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7994         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7995
7996         /* FIXME: use matrix-type input source selection */
7997         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7998         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7999         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8000         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8001         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8002         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8003         /* Input mixer2 */
8004         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8005         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8006         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8007         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8008         /* Input mixer3 */
8009         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8010         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8011         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8012         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8013         /* ADC1: mute amp left and right */
8014         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8015         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8016         /* ADC2: mute amp left and right */
8017         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8018         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8019         /* ADC3: mute amp left and right */
8020         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8021         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8022
8023         { }
8024 };
8025
8026 /* Macbook 5,1 */
8027 static struct hda_verb alc885_mb5_init_verbs[] = {
8028         /* DACs */
8029         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8030         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8031         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8032         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8033         /* Front mixer */
8034         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8035         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8036         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8037         /* Surround mixer */
8038         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8039         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8040         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8041         /* LFE mixer */
8042         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8043         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8044         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8045         /* HP mixer */
8046         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8047         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8048         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8049         /* Front Pin (0x0c) */
8050         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8051         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8052         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8053         /* LFE Pin (0x0e) */
8054         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8055         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8056         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8057         /* HP Pin (0x0f) */
8058         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8059         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8060         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8061         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8062         /* Front Mic pin: input vref at 80% */
8063         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8064         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8065         /* Line In pin */
8066         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8067         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8068
8069         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0x1)},
8070         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x7)},
8071         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0x4)},
8072         { }
8073 };
8074
8075 /* Macmini 3,1 */
8076 static struct hda_verb alc885_macmini3_init_verbs[] = {
8077         /* DACs */
8078         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8079         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8080         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8081         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8082         /* Front mixer */
8083         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8084         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8085         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8086         /* Surround mixer */
8087         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8088         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8089         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8090         /* LFE mixer */
8091         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8092         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8093         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8094         /* HP mixer */
8095         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8096         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8097         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8098         /* Front Pin (0x0c) */
8099         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8101         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8102         /* LFE Pin (0x0e) */
8103         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
8104         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8105         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
8106         /* HP Pin (0x0f) */
8107         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8108         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8109         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
8110         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8111         /* Line In pin */
8112         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8113         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8114
8115         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8116         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8117         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8118         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8119         { }
8120 };
8121
8122
8123 static struct hda_verb alc885_mba21_init_verbs[] = {
8124         /*Internal and HP Speaker Mixer*/
8125         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8126         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8127         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8128         /*Internal Speaker Pin (0x0c)*/
8129         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8130         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8131         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8132         /* HP Pin: output 0 (0x0e) */
8133         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8134         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8135         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8136         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8137         /* Line in (is hp when jack connected)*/
8138         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8139         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8140
8141         { }
8142  };
8143
8144
8145 /* Macbook Pro rev3 */
8146 static struct hda_verb alc885_mbp3_init_verbs[] = {
8147         /* Front mixer: unmute input/output amp left and right (volume = 0) */
8148         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8149         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8150         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8151         /* Rear mixer */
8152         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8153         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8154         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8155         /* HP mixer */
8156         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8157         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8158         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8159         /* Front Pin: output 0 (0x0c) */
8160         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8161         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8162         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8163         /* HP Pin: output 0 (0x0e) */
8164         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
8165         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8166         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
8167         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8168         /* Mic (rear) pin: input vref at 80% */
8169         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8170         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8171         /* Front Mic pin: input vref at 80% */
8172         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8173         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8174         /* Line In pin: use output 1 when in LineOut mode */
8175         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
8176         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8177         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8178
8179         /* FIXME: use matrix-type input source selection */
8180         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8181         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
8182         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8183         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8184         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8185         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8186         /* Input mixer2 */
8187         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8188         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8189         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8190         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8191         /* Input mixer3 */
8192         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8193         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8194         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8195         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8196         /* ADC1: mute amp left and right */
8197         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8198         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8199         /* ADC2: mute amp left and right */
8200         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8201         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8202         /* ADC3: mute amp left and right */
8203         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8204         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8205
8206         { }
8207 };
8208
8209 /* iMac 9,1 */
8210 static struct hda_verb alc885_imac91_init_verbs[] = {
8211         /* Internal Speaker Pin (0x0c) */
8212         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8213         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8214         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8215         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
8216         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8217         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8218         /* HP Pin: Rear */
8219         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8220         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8221         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8222         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
8223         /* Line in Rear */
8224         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
8225         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8226         /* Front Mic pin: input vref at 80% */
8227         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8228         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8229         /* Rear mixer */
8230         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8231         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8232         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8233         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
8234         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8235         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8236         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8237         /* 0x24 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8238         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8239         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8240         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8241         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8242         /* 0x23 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8243         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8244         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8245         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8246         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8247         /* 0x22 [Audio Mixer] wcaps 0x20010b: Stereo Amp-In */
8248         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8249         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
8250         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
8251         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
8252         /* 0x07 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8253         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8254         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
8255         /* 0x08 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8256         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8257         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8258         /* 0x09 [Audio Input] wcaps 0x10011b: Stereo Amp-In */
8259         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8260         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8261         { }
8262 };
8263
8264 /* iMac 24 mixer. */
8265 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
8266         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8267         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
8268         { } /* end */
8269 };
8270
8271 /* iMac 24 init verbs. */
8272 static struct hda_verb alc885_imac24_init_verbs[] = {
8273         /* Internal speakers: output 0 (0x0c) */
8274         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8275         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8276         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
8277         /* Internal speakers: output 0 (0x0c) */
8278         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8279         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8280         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8281         /* Headphone: output 0 (0x0c) */
8282         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8283         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8284         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8285         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8286         /* Front Mic: input vref at 80% */
8287         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
8288         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
8289         { }
8290 };
8291
8292 /* Toggle speaker-output according to the hp-jack state */
8293 static void alc885_imac24_setup(struct hda_codec *codec)
8294 {
8295         struct alc_spec *spec = codec->spec;
8296
8297         spec->autocfg.hp_pins[0] = 0x14;
8298         spec->autocfg.speaker_pins[0] = 0x18;
8299         spec->autocfg.speaker_pins[1] = 0x1a;
8300 }
8301
8302 #define alc885_mb5_setup        alc885_imac24_setup
8303 #define alc885_macmini3_setup   alc885_imac24_setup
8304
8305 /* Macbook Air 2,1 */
8306 static void alc885_mba21_setup(struct hda_codec *codec)
8307 {
8308        struct alc_spec *spec = codec->spec;
8309
8310        spec->autocfg.hp_pins[0] = 0x14;
8311        spec->autocfg.speaker_pins[0] = 0x18;
8312 }
8313
8314
8315
8316 static void alc885_mbp3_setup(struct hda_codec *codec)
8317 {
8318         struct alc_spec *spec = codec->spec;
8319
8320         spec->autocfg.hp_pins[0] = 0x15;
8321         spec->autocfg.speaker_pins[0] = 0x14;
8322 }
8323
8324 static void alc885_imac91_setup(struct hda_codec *codec)
8325 {
8326         struct alc_spec *spec = codec->spec;
8327
8328         spec->autocfg.hp_pins[0] = 0x14;
8329         spec->autocfg.speaker_pins[0] = 0x18;
8330         spec->autocfg.speaker_pins[1] = 0x1a;
8331 }
8332
8333 static struct hda_verb alc882_targa_verbs[] = {
8334         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8335         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8336
8337         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8338         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8339
8340         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8341         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8342         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8343
8344         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8345         { } /* end */
8346 };
8347
8348 /* toggle speaker-output according to the hp-jack state */
8349 static void alc882_targa_automute(struct hda_codec *codec)
8350 {
8351         struct alc_spec *spec = codec->spec;
8352         alc_automute_amp(codec);
8353         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8354                                   spec->jack_present ? 1 : 3);
8355 }
8356
8357 static void alc882_targa_setup(struct hda_codec *codec)
8358 {
8359         struct alc_spec *spec = codec->spec;
8360
8361         spec->autocfg.hp_pins[0] = 0x14;
8362         spec->autocfg.speaker_pins[0] = 0x1b;
8363 }
8364
8365 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8366 {
8367         if ((res >> 26) == ALC880_HP_EVENT)
8368                 alc882_targa_automute(codec);
8369 }
8370
8371 static struct hda_verb alc882_asus_a7j_verbs[] = {
8372         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8373         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8374
8375         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8376         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8377         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8378
8379         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8380         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8381         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8382
8383         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8384         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8385         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8386         { } /* end */
8387 };
8388
8389 static struct hda_verb alc882_asus_a7m_verbs[] = {
8390         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8391         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8392
8393         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8394         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8395         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8396
8397         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8398         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8399         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8400
8401         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8402         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8403         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8404         { } /* end */
8405 };
8406
8407 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8408 {
8409         unsigned int gpiostate, gpiomask, gpiodir;
8410
8411         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8412                                        AC_VERB_GET_GPIO_DATA, 0);
8413
8414         if (!muted)
8415                 gpiostate |= (1 << pin);
8416         else
8417                 gpiostate &= ~(1 << pin);
8418
8419         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8420                                       AC_VERB_GET_GPIO_MASK, 0);
8421         gpiomask |= (1 << pin);
8422
8423         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8424                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8425         gpiodir |= (1 << pin);
8426
8427
8428         snd_hda_codec_write(codec, codec->afg, 0,
8429                             AC_VERB_SET_GPIO_MASK, gpiomask);
8430         snd_hda_codec_write(codec, codec->afg, 0,
8431                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8432
8433         msleep(1);
8434
8435         snd_hda_codec_write(codec, codec->afg, 0,
8436                             AC_VERB_SET_GPIO_DATA, gpiostate);
8437 }
8438
8439 /* set up GPIO at initialization */
8440 static void alc885_macpro_init_hook(struct hda_codec *codec)
8441 {
8442         alc882_gpio_mute(codec, 0, 0);
8443         alc882_gpio_mute(codec, 1, 0);
8444 }
8445
8446 /* set up GPIO and update auto-muting at initialization */
8447 static void alc885_imac24_init_hook(struct hda_codec *codec)
8448 {
8449         alc885_macpro_init_hook(codec);
8450         alc_automute_amp(codec);
8451 }
8452
8453 /*
8454  * generic initialization of ADC, input mixers and output mixers
8455  */
8456 static struct hda_verb alc883_auto_init_verbs[] = {
8457         /*
8458          * Unmute ADC0-2 and set the default input to mic-in
8459          */
8460         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8461         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8462         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8463         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8464
8465         /*
8466          * Set up output mixers (0x0c - 0x0f)
8467          */
8468         /* set vol=0 to output mixers */
8469         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8470         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8471         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8472         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8473         /* set up input amps for analog loopback */
8474         /* Amp Indices: DAC = 0, mixer = 1 */
8475         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8476         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8477         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8478         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8479         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8480         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8481         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8482         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8483         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8484         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8485
8486         /* FIXME: use matrix-type input source selection */
8487         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8488         /* Input mixer2 */
8489         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8490         /* Input mixer3 */
8491         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8492         { }
8493 };
8494
8495 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8496 static struct hda_verb alc889A_mb31_ch2_init[] = {
8497         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8498         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8499         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8500         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8501         { } /* end */
8502 };
8503
8504 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8505 static struct hda_verb alc889A_mb31_ch4_init[] = {
8506         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8507         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8508         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8509         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8510         { } /* end */
8511 };
8512
8513 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8514 static struct hda_verb alc889A_mb31_ch5_init[] = {
8515         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8516         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8517         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8518         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8519         { } /* end */
8520 };
8521
8522 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8523 static struct hda_verb alc889A_mb31_ch6_init[] = {
8524         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8525         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8526         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8527         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8528         { } /* end */
8529 };
8530
8531 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8532         { 2, alc889A_mb31_ch2_init },
8533         { 4, alc889A_mb31_ch4_init },
8534         { 5, alc889A_mb31_ch5_init },
8535         { 6, alc889A_mb31_ch6_init },
8536 };
8537
8538 static struct hda_verb alc883_medion_eapd_verbs[] = {
8539         /* eanable EAPD on medion laptop */
8540         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8541         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8542         { }
8543 };
8544
8545 #define alc883_base_mixer       alc882_base_mixer
8546
8547 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8548         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8549         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8550         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8551         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8552         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8553         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8554         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8555         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8556         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8557         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8558         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8559         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8560         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8561         { } /* end */
8562 };
8563
8564 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8565         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8566         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8567         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8568         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8569         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8570         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8571         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8572         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8573         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8574         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8575         { } /* end */
8576 };
8577
8578 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8579         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8580         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8581         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8582         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8583         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8584         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8585         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8586         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8587         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8588         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8589         { } /* end */
8590 };
8591
8592 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8593         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8594         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8595         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8596         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8597         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8598         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8599         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8600         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8601         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8602         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8603         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8604         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8605         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8606         { } /* end */
8607 };
8608
8609 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8610         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8611         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8612         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8613         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8614         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8615         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8616         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8617         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8618         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8619         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8620         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8621         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8622         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8623         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8624         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8625         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8626         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8627         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8628         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8629         { } /* end */
8630 };
8631
8632 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8633         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8634         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8635         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8636         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8637         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8638                               HDA_OUTPUT),
8639         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8640         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8641         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8642         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8643         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8644         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8645         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8646         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8647         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8648         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8649         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8650         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8651         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8652         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8653         { } /* end */
8654 };
8655
8656 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8657         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8658         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8659         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8660         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8661         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8662                               HDA_OUTPUT),
8663         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8664         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8665         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8666         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8667         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8668         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8669         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8670         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8671         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8672         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8673         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8674         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8675         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8676         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8677         { } /* end */
8678 };
8679
8680 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8681         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8682         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8683         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8684         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8685         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8686         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8687         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8688         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8689         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8690         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8691         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8692         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8693         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8694         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8695         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8696         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8697         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8698         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8699         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8700         { } /* end */
8701 };
8702
8703 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8704         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8705         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8706         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8707         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8708         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8709         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8710         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8711         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8712         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8713         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8714         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8715         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8716         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8717         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8718         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8719         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8720         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8721         { } /* end */
8722 };
8723
8724 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8725         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8726         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8727         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8728         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8729         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8730         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8731         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8732         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8733         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8734         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8735         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8736         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8737         { } /* end */
8738 };
8739
8740 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8741         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8742         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8743         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8744         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8745         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8746         { } /* end */
8747 };
8748
8749 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8750         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8751         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8752         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8753         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8754         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8755         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8756         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8757         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8758         { } /* end */
8759 };
8760
8761 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8762         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8763         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8764         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8765         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8766         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8767         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8768         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8769         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8770         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8771         { } /* end */
8772 };
8773
8774 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8775         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8776         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8777         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8778         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8779         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8780         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8781         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8782         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8783         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8784         { } /* end */
8785 };
8786
8787 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
8788         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8789         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8790         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8791         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
8792         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
8793         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
8794         { } /* end */
8795 };
8796
8797 static struct hda_verb alc883_medion_wim2160_verbs[] = {
8798         /* Unmute front mixer */
8799         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8800         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8801
8802         /* Set speaker pin to front mixer */
8803         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8804
8805         /* Init headphone pin */
8806         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8807         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8808         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8809         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8810
8811         { } /* end */
8812 };
8813
8814 /* toggle speaker-output according to the hp-jack state */
8815 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
8816 {
8817         struct alc_spec *spec = codec->spec;
8818
8819         spec->autocfg.hp_pins[0] = 0x1a;
8820         spec->autocfg.speaker_pins[0] = 0x15;
8821 }
8822
8823 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8824         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8825         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8826         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8827         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8828         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8829         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8830         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8831         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8832         { } /* end */
8833 };
8834
8835 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8836         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8837         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8838         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8839         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8840         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8841         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8842         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8843         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8844         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8845         { } /* end */
8846 };
8847
8848 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8849         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8850         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8851         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8852         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8853         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8854                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8855         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8856         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8857         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8858         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8859         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8860         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8861         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8862         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8863         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8864         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8865         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8866         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8867         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8868         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8869         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8870         { } /* end */
8871 };
8872
8873 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8874         /* Output mixers */
8875         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8876         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8877         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8878         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8879         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8880                 HDA_OUTPUT),
8881         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8882         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8883         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8884         /* Output switches */
8885         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8886         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8887         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8888         /* Boost mixers */
8889         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8890         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8891         /* Input mixers */
8892         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8893         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8894         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8895         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8896         { } /* end */
8897 };
8898
8899 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8900         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8901         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8902         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8903         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8904         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8905         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8906         { } /* end */
8907 };
8908
8909 static struct hda_bind_ctls alc883_bind_cap_vol = {
8910         .ops = &snd_hda_bind_vol,
8911         .values = {
8912                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8913                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8914                 0
8915         },
8916 };
8917
8918 static struct hda_bind_ctls alc883_bind_cap_switch = {
8919         .ops = &snd_hda_bind_sw,
8920         .values = {
8921                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8922                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8923                 0
8924         },
8925 };
8926
8927 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8928         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8929         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8930         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8931         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8932         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8933         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8934         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8935         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8936         { } /* end */
8937 };
8938
8939 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8940         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8941         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8942         {
8943                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8944                 /* .name = "Capture Source", */
8945                 .name = "Input Source",
8946                 .count = 1,
8947                 .info = alc_mux_enum_info,
8948                 .get = alc_mux_enum_get,
8949                 .put = alc_mux_enum_put,
8950         },
8951         { } /* end */
8952 };
8953
8954 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8955         {
8956                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8957                 .name = "Channel Mode",
8958                 .info = alc_ch_mode_info,
8959                 .get = alc_ch_mode_get,
8960                 .put = alc_ch_mode_put,
8961         },
8962         { } /* end */
8963 };
8964
8965 /* toggle speaker-output according to the hp-jack state */
8966 static void alc883_mitac_setup(struct hda_codec *codec)
8967 {
8968         struct alc_spec *spec = codec->spec;
8969
8970         spec->autocfg.hp_pins[0] = 0x15;
8971         spec->autocfg.speaker_pins[0] = 0x14;
8972         spec->autocfg.speaker_pins[1] = 0x17;
8973 }
8974
8975 /* auto-toggle front mic */
8976 /*
8977 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8978 {
8979         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8980
8981         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8982 }
8983 */
8984
8985 static struct hda_verb alc883_mitac_verbs[] = {
8986         /* HP */
8987         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8988         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8989         /* Subwoofer */
8990         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8991         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8992
8993         /* enable unsolicited event */
8994         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8995         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8996
8997         { } /* end */
8998 };
8999
9000 static struct hda_verb alc883_clevo_m540r_verbs[] = {
9001         /* HP */
9002         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9003         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9004         /* Int speaker */
9005         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
9006
9007         /* enable unsolicited event */
9008         /*
9009         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9011         */
9012
9013         { } /* end */
9014 };
9015
9016 static struct hda_verb alc883_clevo_m720_verbs[] = {
9017         /* HP */
9018         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9020         /* Int speaker */
9021         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
9022         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9023
9024         /* enable unsolicited event */
9025         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9026         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9027
9028         { } /* end */
9029 };
9030
9031 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
9032         /* HP */
9033         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9034         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9035         /* Subwoofer */
9036         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
9037         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9038
9039         /* enable unsolicited event */
9040         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9041
9042         { } /* end */
9043 };
9044
9045 static struct hda_verb alc883_targa_verbs[] = {
9046         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9047         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9048
9049         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9050         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9051
9052 /* Connect Line-Out side jack (SPDIF) to Side */
9053         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9054         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9055         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
9056 /* Connect Mic jack to CLFE */
9057         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9058         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9059         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
9060 /* Connect Line-in jack to Surround */
9061         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9062         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9063         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
9064 /* Connect HP out jack to Front */
9065         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9066         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9067         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9068
9069         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9070
9071         { } /* end */
9072 };
9073
9074 static struct hda_verb alc883_lenovo_101e_verbs[] = {
9075         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9076         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
9077         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
9078         { } /* end */
9079 };
9080
9081 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
9082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9083         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9084         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9085         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9086         { } /* end */
9087 };
9088
9089 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
9090         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9091         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9092         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9093         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
9094         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
9095         { } /* end */
9096 };
9097
9098 static struct hda_verb alc883_haier_w66_verbs[] = {
9099         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9100         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9101
9102         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9103
9104         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
9105         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9106         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9107         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9108         { } /* end */
9109 };
9110
9111 static struct hda_verb alc888_lenovo_sky_verbs[] = {
9112         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9113         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9114         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9115         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9116         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9117         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9118         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
9119         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9120         { } /* end */
9121 };
9122
9123 static struct hda_verb alc888_6st_dell_verbs[] = {
9124         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9125         { }
9126 };
9127
9128 static struct hda_verb alc883_vaiott_verbs[] = {
9129         /* HP */
9130         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9131         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9132
9133         /* enable unsolicited event */
9134         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9135
9136         { } /* end */
9137 };
9138
9139 static void alc888_3st_hp_setup(struct hda_codec *codec)
9140 {
9141         struct alc_spec *spec = codec->spec;
9142
9143         spec->autocfg.hp_pins[0] = 0x1b;
9144         spec->autocfg.speaker_pins[0] = 0x14;
9145         spec->autocfg.speaker_pins[1] = 0x16;
9146         spec->autocfg.speaker_pins[2] = 0x18;
9147 }
9148
9149 static struct hda_verb alc888_3st_hp_verbs[] = {
9150         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
9151         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
9152         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
9153         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9154         { } /* end */
9155 };
9156
9157 /*
9158  * 2ch mode
9159  */
9160 static struct hda_verb alc888_3st_hp_2ch_init[] = {
9161         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9162         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9163         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
9164         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9165         { } /* end */
9166 };
9167
9168 /*
9169  * 4ch mode
9170  */
9171 static struct hda_verb alc888_3st_hp_4ch_init[] = {
9172         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
9173         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
9174         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9175         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9176         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9177         { } /* end */
9178 };
9179
9180 /*
9181  * 6ch mode
9182  */
9183 static struct hda_verb alc888_3st_hp_6ch_init[] = {
9184         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9185         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9186         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
9187         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
9188         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
9189         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
9190         { } /* end */
9191 };
9192
9193 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
9194         { 2, alc888_3st_hp_2ch_init },
9195         { 4, alc888_3st_hp_4ch_init },
9196         { 6, alc888_3st_hp_6ch_init },
9197 };
9198
9199 /* toggle front-jack and RCA according to the hp-jack state */
9200 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
9201 {
9202         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
9203
9204         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9205                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9206         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9207                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9208 }
9209
9210 /* toggle RCA according to the front-jack state */
9211 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
9212 {
9213         unsigned int present = snd_hda_jack_detect(codec, 0x14);
9214
9215         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9216                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9217 }
9218
9219 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
9220                                              unsigned int res)
9221 {
9222         if ((res >> 26) == ALC880_HP_EVENT)
9223                 alc888_lenovo_ms7195_front_automute(codec);
9224         if ((res >> 26) == ALC880_FRONT_EVENT)
9225                 alc888_lenovo_ms7195_rca_automute(codec);
9226 }
9227
9228 static struct hda_verb alc883_medion_md2_verbs[] = {
9229         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9230         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9231
9232         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9233
9234         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9235         { } /* end */
9236 };
9237
9238 /* toggle speaker-output according to the hp-jack state */
9239 static void alc883_medion_md2_setup(struct hda_codec *codec)
9240 {
9241         struct alc_spec *spec = codec->spec;
9242
9243         spec->autocfg.hp_pins[0] = 0x14;
9244         spec->autocfg.speaker_pins[0] = 0x15;
9245 }
9246
9247 /* toggle speaker-output according to the hp-jack state */
9248 #define alc883_targa_init_hook          alc882_targa_init_hook
9249 #define alc883_targa_unsol_event        alc882_targa_unsol_event
9250
9251 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
9252 {
9253         unsigned int present;
9254
9255         present = snd_hda_jack_detect(codec, 0x18);
9256         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
9257                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9258 }
9259
9260 static void alc883_clevo_m720_setup(struct hda_codec *codec)
9261 {
9262         struct alc_spec *spec = codec->spec;
9263
9264         spec->autocfg.hp_pins[0] = 0x15;
9265         spec->autocfg.speaker_pins[0] = 0x14;
9266 }
9267
9268 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
9269 {
9270         alc_automute_amp(codec);
9271         alc883_clevo_m720_mic_automute(codec);
9272 }
9273
9274 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
9275                                            unsigned int res)
9276 {
9277         switch (res >> 26) {
9278         case ALC880_MIC_EVENT:
9279                 alc883_clevo_m720_mic_automute(codec);
9280                 break;
9281         default:
9282                 alc_automute_amp_unsol_event(codec, res);
9283                 break;
9284         }
9285 }
9286
9287 /* toggle speaker-output according to the hp-jack state */
9288 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
9289 {
9290         struct alc_spec *spec = codec->spec;
9291
9292         spec->autocfg.hp_pins[0] = 0x14;
9293         spec->autocfg.speaker_pins[0] = 0x15;
9294 }
9295
9296 static void alc883_haier_w66_setup(struct hda_codec *codec)
9297 {
9298         struct alc_spec *spec = codec->spec;
9299
9300         spec->autocfg.hp_pins[0] = 0x1b;
9301         spec->autocfg.speaker_pins[0] = 0x14;
9302 }
9303
9304 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
9305 {
9306         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
9307
9308         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9309                                  HDA_AMP_MUTE, bits);
9310 }
9311
9312 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
9313 {
9314         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
9315
9316         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
9317                                  HDA_AMP_MUTE, bits);
9318         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
9319                                  HDA_AMP_MUTE, bits);
9320 }
9321
9322 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
9323                                            unsigned int res)
9324 {
9325         if ((res >> 26) == ALC880_HP_EVENT)
9326                 alc883_lenovo_101e_all_automute(codec);
9327         if ((res >> 26) == ALC880_FRONT_EVENT)
9328                 alc883_lenovo_101e_ispeaker_automute(codec);
9329 }
9330
9331 /* toggle speaker-output according to the hp-jack state */
9332 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9333 {
9334         struct alc_spec *spec = codec->spec;
9335
9336         spec->autocfg.hp_pins[0] = 0x14;
9337         spec->autocfg.speaker_pins[0] = 0x15;
9338         spec->autocfg.speaker_pins[1] = 0x16;
9339 }
9340
9341 static struct hda_verb alc883_acer_eapd_verbs[] = {
9342         /* HP Pin: output 0 (0x0c) */
9343         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9344         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9345         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9346         /* Front Pin: output 0 (0x0c) */
9347         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9348         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9349         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9350         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9351         /* eanable EAPD on medion laptop */
9352         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9353         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9354         /* enable unsolicited event */
9355         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9356         { }
9357 };
9358
9359 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
9360         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9361         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9362         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9363         { } /* end */
9364 };
9365
9366 static void alc888_6st_dell_setup(struct hda_codec *codec)
9367 {
9368         struct alc_spec *spec = codec->spec;
9369
9370         spec->autocfg.hp_pins[0] = 0x1b;
9371         spec->autocfg.speaker_pins[0] = 0x14;
9372         spec->autocfg.speaker_pins[1] = 0x15;
9373         spec->autocfg.speaker_pins[2] = 0x16;
9374         spec->autocfg.speaker_pins[3] = 0x17;
9375 }
9376
9377 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9378 {
9379         struct alc_spec *spec = codec->spec;
9380
9381         spec->autocfg.hp_pins[0] = 0x1b;
9382         spec->autocfg.speaker_pins[0] = 0x14;
9383         spec->autocfg.speaker_pins[1] = 0x15;
9384         spec->autocfg.speaker_pins[2] = 0x16;
9385         spec->autocfg.speaker_pins[3] = 0x17;
9386         spec->autocfg.speaker_pins[4] = 0x1a;
9387 }
9388
9389 static void alc883_vaiott_setup(struct hda_codec *codec)
9390 {
9391         struct alc_spec *spec = codec->spec;
9392
9393         spec->autocfg.hp_pins[0] = 0x15;
9394         spec->autocfg.speaker_pins[0] = 0x14;
9395         spec->autocfg.speaker_pins[1] = 0x17;
9396 }
9397
9398 static struct hda_verb alc888_asus_m90v_verbs[] = {
9399         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9400         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9401         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9402         /* enable unsolicited event */
9403         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9404         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9405         { } /* end */
9406 };
9407
9408 static void alc883_mode2_setup(struct hda_codec *codec)
9409 {
9410         struct alc_spec *spec = codec->spec;
9411
9412         spec->autocfg.hp_pins[0] = 0x1b;
9413         spec->autocfg.speaker_pins[0] = 0x14;
9414         spec->autocfg.speaker_pins[1] = 0x15;
9415         spec->autocfg.speaker_pins[2] = 0x16;
9416         spec->ext_mic.pin = 0x18;
9417         spec->int_mic.pin = 0x19;
9418         spec->ext_mic.mux_idx = 0;
9419         spec->int_mic.mux_idx = 1;
9420         spec->auto_mic = 1;
9421 }
9422
9423 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9424         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9425         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9426         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9427         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9428         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9429         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9430         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9431         /* enable unsolicited event */
9432         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9433         { } /* end */
9434 };
9435
9436 static void alc883_eee1601_inithook(struct hda_codec *codec)
9437 {
9438         struct alc_spec *spec = codec->spec;
9439
9440         spec->autocfg.hp_pins[0] = 0x14;
9441         spec->autocfg.speaker_pins[0] = 0x1b;
9442         alc_automute_pin(codec);
9443 }
9444
9445 static struct hda_verb alc889A_mb31_verbs[] = {
9446         /* Init rear pin (used as headphone output) */
9447         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9448         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9449         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9450         /* Init line pin (used as output in 4ch and 6ch mode) */
9451         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9452         /* Init line 2 pin (used as headphone out by default) */
9453         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9454         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9455         { } /* end */
9456 };
9457
9458 /* Mute speakers according to the headphone jack state */
9459 static void alc889A_mb31_automute(struct hda_codec *codec)
9460 {
9461         unsigned int present;
9462
9463         /* Mute only in 2ch or 4ch mode */
9464         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9465             == 0x00) {
9466                 present = snd_hda_jack_detect(codec, 0x15);
9467                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9468                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9469                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9470                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9471         }
9472 }
9473
9474 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9475 {
9476         if ((res >> 26) == ALC880_HP_EVENT)
9477                 alc889A_mb31_automute(codec);
9478 }
9479
9480
9481 #ifdef CONFIG_SND_HDA_POWER_SAVE
9482 #define alc882_loopbacks        alc880_loopbacks
9483 #endif
9484
9485 /* pcm configuration: identical with ALC880 */
9486 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9487 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9488 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9489 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9490
9491 static hda_nid_t alc883_slave_dig_outs[] = {
9492         ALC1200_DIGOUT_NID, 0,
9493 };
9494
9495 static hda_nid_t alc1200_slave_dig_outs[] = {
9496         ALC883_DIGOUT_NID, 0,
9497 };
9498
9499 /*
9500  * configuration and preset
9501  */
9502 static const char *alc882_models[ALC882_MODEL_LAST] = {
9503         [ALC882_3ST_DIG]        = "3stack-dig",
9504         [ALC882_6ST_DIG]        = "6stack-dig",
9505         [ALC882_ARIMA]          = "arima",
9506         [ALC882_W2JC]           = "w2jc",
9507         [ALC882_TARGA]          = "targa",
9508         [ALC882_ASUS_A7J]       = "asus-a7j",
9509         [ALC882_ASUS_A7M]       = "asus-a7m",
9510         [ALC885_MACPRO]         = "macpro",
9511         [ALC885_MB5]            = "mb5",
9512         [ALC885_MACMINI3]       = "macmini3",
9513         [ALC885_MBA21]          = "mba21",
9514         [ALC885_MBP3]           = "mbp3",
9515         [ALC885_IMAC24]         = "imac24",
9516         [ALC885_IMAC91]         = "imac91",
9517         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9518         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9519         [ALC883_3ST_6ch]        = "3stack-6ch",
9520         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9521         [ALC883_TARGA_DIG]      = "targa-dig",
9522         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9523         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9524         [ALC883_ACER]           = "acer",
9525         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9526         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9527         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9528         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9529         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9530         [ALC883_MEDION]         = "medion",
9531         [ALC883_MEDION_MD2]     = "medion-md2",
9532         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9533         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9534         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9535         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9536         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9537         [ALC888_LENOVO_SKY] = "lenovo-sky",
9538         [ALC883_HAIER_W66]      = "haier-w66",
9539         [ALC888_3ST_HP]         = "3stack-hp",
9540         [ALC888_6ST_DELL]       = "6stack-dell",
9541         [ALC883_MITAC]          = "mitac",
9542         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9543         [ALC883_CLEVO_M720]     = "clevo-m720",
9544         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9545         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9546         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9547         [ALC889A_INTEL]         = "intel-alc889a",
9548         [ALC889_INTEL]          = "intel-x58",
9549         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9550         [ALC889A_MB31]          = "mb31",
9551         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9552         [ALC882_AUTO]           = "auto",
9553 };
9554
9555 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9556         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9557
9558         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9559         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9560         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9561         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9562         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9563         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9564         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9565                 ALC888_ACER_ASPIRE_4930G),
9566         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9567                 ALC888_ACER_ASPIRE_4930G),
9568         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9569                 ALC888_ACER_ASPIRE_8930G),
9570         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9571                 ALC888_ACER_ASPIRE_8930G),
9572         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9573         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9574         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9575                 ALC888_ACER_ASPIRE_6530G),
9576         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9577                 ALC888_ACER_ASPIRE_6530G),
9578         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9579                 ALC888_ACER_ASPIRE_7730G),
9580         /* default Acer -- disabled as it causes more problems.
9581          *    model=auto should work fine now
9582          */
9583         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9584
9585         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9586
9587         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9588         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9589         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9590         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9591         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9592         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9593
9594         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9595         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9596         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9597         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9598         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9599         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9600         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9601         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9602         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9603         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9604         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9605
9606         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9607         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9608         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9609         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9610         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9611         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9612         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9613         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9614         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9615
9616         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9617         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9618         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9619         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9620         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9621         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9622         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9623         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9624         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9625         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9626         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9627         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9628         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9629         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9630         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9631         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9632         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9633         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9634         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9635         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9636         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9637         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9638         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9639         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9640         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9641         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9642         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9643         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9644         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9645         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9646         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9647
9648         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9649         SND_PCI_QUIRK(0x1558, 0x0571, "Clevo laptop M570U", ALC883_3ST_6ch_DIG),
9650         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9651         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9652         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9653         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9654         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9655         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9656         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9657         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9658                       ALC883_FUJITSU_PI2515),
9659         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9660                 ALC888_FUJITSU_XA3530),
9661         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9662         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9663         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9664         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9665         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9666         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9667         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9668         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9669         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9670
9671         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9672         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9673         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9674         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9675         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9676         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9677         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9678
9679         {}
9680 };
9681
9682 /* codec SSID table for Intel Mac */
9683 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9684         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9685         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9686         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9687         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9688         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9689         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9690         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9691         SND_PCI_QUIRK(0x106b, 0x3000, "iMac", ALC889A_MB31),
9692         SND_PCI_QUIRK(0x106b, 0x3200, "iMac 7,1 Aluminum", ALC882_ASUS_A7M),
9693         SND_PCI_QUIRK(0x106b, 0x3400, "MacBookAir 1,1", ALC885_MBP3),
9694         SND_PCI_QUIRK(0x106b, 0x3500, "MacBookAir 2,1", ALC885_MBA21),
9695         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9696         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9697         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9698         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9699         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9700         SND_PCI_QUIRK(0x106b, 0x4a00, "Macbook 5,2", ALC885_MB5),
9701         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9702          * so apparently no perfect solution yet
9703          */
9704         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9705         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9706         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9707         {} /* terminator */
9708 };
9709
9710 static struct alc_config_preset alc882_presets[] = {
9711         [ALC882_3ST_DIG] = {
9712                 .mixers = { alc882_base_mixer },
9713                 .init_verbs = { alc882_base_init_verbs,
9714                                 alc882_adc1_init_verbs },
9715                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9716                 .dac_nids = alc882_dac_nids,
9717                 .dig_out_nid = ALC882_DIGOUT_NID,
9718                 .dig_in_nid = ALC882_DIGIN_NID,
9719                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9720                 .channel_mode = alc882_ch_modes,
9721                 .need_dac_fix = 1,
9722                 .input_mux = &alc882_capture_source,
9723         },
9724         [ALC882_6ST_DIG] = {
9725                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9726                 .init_verbs = { alc882_base_init_verbs,
9727                                 alc882_adc1_init_verbs },
9728                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9729                 .dac_nids = alc882_dac_nids,
9730                 .dig_out_nid = ALC882_DIGOUT_NID,
9731                 .dig_in_nid = ALC882_DIGIN_NID,
9732                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9733                 .channel_mode = alc882_sixstack_modes,
9734                 .input_mux = &alc882_capture_source,
9735         },
9736         [ALC882_ARIMA] = {
9737                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9738                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9739                                 alc882_eapd_verbs },
9740                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9741                 .dac_nids = alc882_dac_nids,
9742                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9743                 .channel_mode = alc882_sixstack_modes,
9744                 .input_mux = &alc882_capture_source,
9745         },
9746         [ALC882_W2JC] = {
9747                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9748                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9749                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9750                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9751                 .dac_nids = alc882_dac_nids,
9752                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9753                 .channel_mode = alc880_threestack_modes,
9754                 .need_dac_fix = 1,
9755                 .input_mux = &alc882_capture_source,
9756                 .dig_out_nid = ALC882_DIGOUT_NID,
9757         },
9758            [ALC885_MBA21] = {
9759                         .mixers = { alc885_mba21_mixer },
9760                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9761                         .num_dacs = 2,
9762                         .dac_nids = alc882_dac_nids,
9763                         .channel_mode = alc885_mba21_ch_modes,
9764                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9765                         .input_mux = &alc882_capture_source,
9766                         .unsol_event = alc_automute_amp_unsol_event,
9767                         .setup = alc885_mba21_setup,
9768                         .init_hook = alc_automute_amp,
9769        },
9770         [ALC885_MBP3] = {
9771                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9772                 .init_verbs = { alc885_mbp3_init_verbs,
9773                                 alc880_gpio1_init_verbs },
9774                 .num_dacs = 2,
9775                 .dac_nids = alc882_dac_nids,
9776                 .hp_nid = 0x04,
9777                 .channel_mode = alc885_mbp_4ch_modes,
9778                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9779                 .input_mux = &alc882_capture_source,
9780                 .dig_out_nid = ALC882_DIGOUT_NID,
9781                 .dig_in_nid = ALC882_DIGIN_NID,
9782                 .unsol_event = alc_automute_amp_unsol_event,
9783                 .setup = alc885_mbp3_setup,
9784                 .init_hook = alc_automute_amp,
9785         },
9786         [ALC885_MB5] = {
9787                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9788                 .init_verbs = { alc885_mb5_init_verbs,
9789                                 alc880_gpio1_init_verbs },
9790                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9791                 .dac_nids = alc882_dac_nids,
9792                 .channel_mode = alc885_mb5_6ch_modes,
9793                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9794                 .input_mux = &mb5_capture_source,
9795                 .dig_out_nid = ALC882_DIGOUT_NID,
9796                 .dig_in_nid = ALC882_DIGIN_NID,
9797                 .unsol_event = alc_automute_amp_unsol_event,
9798                 .setup = alc885_mb5_setup,
9799                 .init_hook = alc_automute_amp,
9800         },
9801         [ALC885_MACMINI3] = {
9802                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9803                 .init_verbs = { alc885_macmini3_init_verbs,
9804                                 alc880_gpio1_init_verbs },
9805                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9806                 .dac_nids = alc882_dac_nids,
9807                 .channel_mode = alc885_macmini3_6ch_modes,
9808                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9809                 .input_mux = &macmini3_capture_source,
9810                 .dig_out_nid = ALC882_DIGOUT_NID,
9811                 .dig_in_nid = ALC882_DIGIN_NID,
9812                 .unsol_event = alc_automute_amp_unsol_event,
9813                 .setup = alc885_macmini3_setup,
9814                 .init_hook = alc_automute_amp,
9815         },
9816         [ALC885_MACPRO] = {
9817                 .mixers = { alc882_macpro_mixer },
9818                 .init_verbs = { alc882_macpro_init_verbs },
9819                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9820                 .dac_nids = alc882_dac_nids,
9821                 .dig_out_nid = ALC882_DIGOUT_NID,
9822                 .dig_in_nid = ALC882_DIGIN_NID,
9823                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9824                 .channel_mode = alc882_ch_modes,
9825                 .input_mux = &alc882_capture_source,
9826                 .init_hook = alc885_macpro_init_hook,
9827         },
9828         [ALC885_IMAC24] = {
9829                 .mixers = { alc885_imac24_mixer },
9830                 .init_verbs = { alc885_imac24_init_verbs },
9831                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9832                 .dac_nids = alc882_dac_nids,
9833                 .dig_out_nid = ALC882_DIGOUT_NID,
9834                 .dig_in_nid = ALC882_DIGIN_NID,
9835                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9836                 .channel_mode = alc882_ch_modes,
9837                 .input_mux = &alc882_capture_source,
9838                 .unsol_event = alc_automute_amp_unsol_event,
9839                 .setup = alc885_imac24_setup,
9840                 .init_hook = alc885_imac24_init_hook,
9841         },
9842         [ALC885_IMAC91] = {
9843                 .mixers = {alc885_imac91_mixer},
9844                 .init_verbs = { alc885_imac91_init_verbs,
9845                                 alc880_gpio1_init_verbs },
9846                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9847                 .dac_nids = alc882_dac_nids,
9848                 .channel_mode = alc885_mba21_ch_modes,
9849                 .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9850                 .input_mux = &alc889A_imac91_capture_source,
9851                 .dig_out_nid = ALC882_DIGOUT_NID,
9852                 .dig_in_nid = ALC882_DIGIN_NID,
9853                 .unsol_event = alc_automute_amp_unsol_event,
9854                 .setup = alc885_imac91_setup,
9855                 .init_hook = alc_automute_amp,
9856         },
9857         [ALC882_TARGA] = {
9858                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9859                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9860                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9861                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9862                 .dac_nids = alc882_dac_nids,
9863                 .dig_out_nid = ALC882_DIGOUT_NID,
9864                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9865                 .adc_nids = alc882_adc_nids,
9866                 .capsrc_nids = alc882_capsrc_nids,
9867                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9868                 .channel_mode = alc882_3ST_6ch_modes,
9869                 .need_dac_fix = 1,
9870                 .input_mux = &alc882_capture_source,
9871                 .unsol_event = alc882_targa_unsol_event,
9872                 .setup = alc882_targa_setup,
9873                 .init_hook = alc882_targa_automute,
9874         },
9875         [ALC882_ASUS_A7J] = {
9876                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9877                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9878                                 alc882_asus_a7j_verbs},
9879                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9880                 .dac_nids = alc882_dac_nids,
9881                 .dig_out_nid = ALC882_DIGOUT_NID,
9882                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9883                 .adc_nids = alc882_adc_nids,
9884                 .capsrc_nids = alc882_capsrc_nids,
9885                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9886                 .channel_mode = alc882_3ST_6ch_modes,
9887                 .need_dac_fix = 1,
9888                 .input_mux = &alc882_capture_source,
9889         },
9890         [ALC882_ASUS_A7M] = {
9891                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9892                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9893                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9894                                 alc882_asus_a7m_verbs },
9895                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9896                 .dac_nids = alc882_dac_nids,
9897                 .dig_out_nid = ALC882_DIGOUT_NID,
9898                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9899                 .channel_mode = alc880_threestack_modes,
9900                 .need_dac_fix = 1,
9901                 .input_mux = &alc882_capture_source,
9902         },
9903         [ALC883_3ST_2ch_DIG] = {
9904                 .mixers = { alc883_3ST_2ch_mixer },
9905                 .init_verbs = { alc883_init_verbs },
9906                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9907                 .dac_nids = alc883_dac_nids,
9908                 .dig_out_nid = ALC883_DIGOUT_NID,
9909                 .dig_in_nid = ALC883_DIGIN_NID,
9910                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9911                 .channel_mode = alc883_3ST_2ch_modes,
9912                 .input_mux = &alc883_capture_source,
9913         },
9914         [ALC883_3ST_6ch_DIG] = {
9915                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9916                 .init_verbs = { alc883_init_verbs },
9917                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9918                 .dac_nids = alc883_dac_nids,
9919                 .dig_out_nid = ALC883_DIGOUT_NID,
9920                 .dig_in_nid = ALC883_DIGIN_NID,
9921                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9922                 .channel_mode = alc883_3ST_6ch_modes,
9923                 .need_dac_fix = 1,
9924                 .input_mux = &alc883_capture_source,
9925         },
9926         [ALC883_3ST_6ch] = {
9927                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9928                 .init_verbs = { alc883_init_verbs },
9929                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9930                 .dac_nids = alc883_dac_nids,
9931                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9932                 .channel_mode = alc883_3ST_6ch_modes,
9933                 .need_dac_fix = 1,
9934                 .input_mux = &alc883_capture_source,
9935         },
9936         [ALC883_3ST_6ch_INTEL] = {
9937                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9938                 .init_verbs = { alc883_init_verbs },
9939                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9940                 .dac_nids = alc883_dac_nids,
9941                 .dig_out_nid = ALC883_DIGOUT_NID,
9942                 .dig_in_nid = ALC883_DIGIN_NID,
9943                 .slave_dig_outs = alc883_slave_dig_outs,
9944                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9945                 .channel_mode = alc883_3ST_6ch_intel_modes,
9946                 .need_dac_fix = 1,
9947                 .input_mux = &alc883_3stack_6ch_intel,
9948         },
9949         [ALC889A_INTEL] = {
9950                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9951                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9952                                 alc_hp15_unsol_verbs },
9953                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9954                 .dac_nids = alc883_dac_nids,
9955                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9956                 .adc_nids = alc889_adc_nids,
9957                 .dig_out_nid = ALC883_DIGOUT_NID,
9958                 .dig_in_nid = ALC883_DIGIN_NID,
9959                 .slave_dig_outs = alc883_slave_dig_outs,
9960                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9961                 .channel_mode = alc889_8ch_intel_modes,
9962                 .capsrc_nids = alc889_capsrc_nids,
9963                 .input_mux = &alc889_capture_source,
9964                 .setup = alc889_automute_setup,
9965                 .init_hook = alc_automute_amp,
9966                 .unsol_event = alc_automute_amp_unsol_event,
9967                 .need_dac_fix = 1,
9968         },
9969         [ALC889_INTEL] = {
9970                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9971                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9972                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9973                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9974                 .dac_nids = alc883_dac_nids,
9975                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9976                 .adc_nids = alc889_adc_nids,
9977                 .dig_out_nid = ALC883_DIGOUT_NID,
9978                 .dig_in_nid = ALC883_DIGIN_NID,
9979                 .slave_dig_outs = alc883_slave_dig_outs,
9980                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9981                 .channel_mode = alc889_8ch_intel_modes,
9982                 .capsrc_nids = alc889_capsrc_nids,
9983                 .input_mux = &alc889_capture_source,
9984                 .setup = alc889_automute_setup,
9985                 .init_hook = alc889_intel_init_hook,
9986                 .unsol_event = alc_automute_amp_unsol_event,
9987                 .need_dac_fix = 1,
9988         },
9989         [ALC883_6ST_DIG] = {
9990                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9991                 .init_verbs = { alc883_init_verbs },
9992                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9993                 .dac_nids = alc883_dac_nids,
9994                 .dig_out_nid = ALC883_DIGOUT_NID,
9995                 .dig_in_nid = ALC883_DIGIN_NID,
9996                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9997                 .channel_mode = alc883_sixstack_modes,
9998                 .input_mux = &alc883_capture_source,
9999         },
10000         [ALC883_TARGA_DIG] = {
10001                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
10002                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10003                                 alc883_targa_verbs},
10004                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10005                 .dac_nids = alc883_dac_nids,
10006                 .dig_out_nid = ALC883_DIGOUT_NID,
10007                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10008                 .channel_mode = alc883_3ST_6ch_modes,
10009                 .need_dac_fix = 1,
10010                 .input_mux = &alc883_capture_source,
10011                 .unsol_event = alc883_targa_unsol_event,
10012                 .setup = alc882_targa_setup,
10013                 .init_hook = alc882_targa_automute,
10014         },
10015         [ALC883_TARGA_2ch_DIG] = {
10016                 .mixers = { alc883_targa_2ch_mixer},
10017                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10018                                 alc883_targa_verbs},
10019                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10020                 .dac_nids = alc883_dac_nids,
10021                 .adc_nids = alc883_adc_nids_alt,
10022                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10023                 .capsrc_nids = alc883_capsrc_nids,
10024                 .dig_out_nid = ALC883_DIGOUT_NID,
10025                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10026                 .channel_mode = alc883_3ST_2ch_modes,
10027                 .input_mux = &alc883_capture_source,
10028                 .unsol_event = alc883_targa_unsol_event,
10029                 .setup = alc882_targa_setup,
10030                 .init_hook = alc882_targa_automute,
10031         },
10032         [ALC883_TARGA_8ch_DIG] = {
10033                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
10034                             alc883_chmode_mixer },
10035                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
10036                                 alc883_targa_verbs },
10037                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10038                 .dac_nids = alc883_dac_nids,
10039                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10040                 .adc_nids = alc883_adc_nids_rev,
10041                 .capsrc_nids = alc883_capsrc_nids_rev,
10042                 .dig_out_nid = ALC883_DIGOUT_NID,
10043                 .dig_in_nid = ALC883_DIGIN_NID,
10044                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
10045                 .channel_mode = alc883_4ST_8ch_modes,
10046                 .need_dac_fix = 1,
10047                 .input_mux = &alc883_capture_source,
10048                 .unsol_event = alc883_targa_unsol_event,
10049                 .setup = alc882_targa_setup,
10050                 .init_hook = alc882_targa_automute,
10051         },
10052         [ALC883_ACER] = {
10053                 .mixers = { alc883_base_mixer },
10054                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
10055                  * and the headphone jack.  Turn this on and rely on the
10056                  * standard mute methods whenever the user wants to turn
10057                  * these outputs off.
10058                  */
10059                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
10060                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10061                 .dac_nids = alc883_dac_nids,
10062                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10063                 .channel_mode = alc883_3ST_2ch_modes,
10064                 .input_mux = &alc883_capture_source,
10065         },
10066         [ALC883_ACER_ASPIRE] = {
10067                 .mixers = { alc883_acer_aspire_mixer },
10068                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
10069                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10070                 .dac_nids = alc883_dac_nids,
10071                 .dig_out_nid = ALC883_DIGOUT_NID,
10072                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10073                 .channel_mode = alc883_3ST_2ch_modes,
10074                 .input_mux = &alc883_capture_source,
10075                 .unsol_event = alc_automute_amp_unsol_event,
10076                 .setup = alc883_acer_aspire_setup,
10077                 .init_hook = alc_automute_amp,
10078         },
10079         [ALC888_ACER_ASPIRE_4930G] = {
10080                 .mixers = { alc888_base_mixer,
10081                                 alc883_chmode_mixer },
10082                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10083                                 alc888_acer_aspire_4930g_verbs },
10084                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10085                 .dac_nids = alc883_dac_nids,
10086                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10087                 .adc_nids = alc883_adc_nids_rev,
10088                 .capsrc_nids = alc883_capsrc_nids_rev,
10089                 .dig_out_nid = ALC883_DIGOUT_NID,
10090                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10091                 .channel_mode = alc883_3ST_6ch_modes,
10092                 .need_dac_fix = 1,
10093                 .const_channel_count = 6,
10094                 .num_mux_defs =
10095                         ARRAY_SIZE(alc888_2_capture_sources),
10096                 .input_mux = alc888_2_capture_sources,
10097                 .unsol_event = alc_automute_amp_unsol_event,
10098                 .setup = alc888_acer_aspire_4930g_setup,
10099                 .init_hook = alc_automute_amp,
10100         },
10101         [ALC888_ACER_ASPIRE_6530G] = {
10102                 .mixers = { alc888_acer_aspire_6530_mixer },
10103                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10104                                 alc888_acer_aspire_6530g_verbs },
10105                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10106                 .dac_nids = alc883_dac_nids,
10107                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10108                 .adc_nids = alc883_adc_nids_rev,
10109                 .capsrc_nids = alc883_capsrc_nids_rev,
10110                 .dig_out_nid = ALC883_DIGOUT_NID,
10111                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10112                 .channel_mode = alc883_3ST_2ch_modes,
10113                 .num_mux_defs =
10114                         ARRAY_SIZE(alc888_2_capture_sources),
10115                 .input_mux = alc888_acer_aspire_6530_sources,
10116                 .unsol_event = alc_automute_amp_unsol_event,
10117                 .setup = alc888_acer_aspire_6530g_setup,
10118                 .init_hook = alc_automute_amp,
10119         },
10120         [ALC888_ACER_ASPIRE_8930G] = {
10121                 .mixers = { alc889_acer_aspire_8930g_mixer,
10122                                 alc883_chmode_mixer },
10123                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10124                                 alc889_acer_aspire_8930g_verbs,
10125                                 alc889_eapd_verbs},
10126                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10127                 .dac_nids = alc883_dac_nids,
10128                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
10129                 .adc_nids = alc889_adc_nids,
10130                 .capsrc_nids = alc889_capsrc_nids,
10131                 .dig_out_nid = ALC883_DIGOUT_NID,
10132                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10133                 .channel_mode = alc883_3ST_6ch_modes,
10134                 .need_dac_fix = 1,
10135                 .const_channel_count = 6,
10136                 .num_mux_defs =
10137                         ARRAY_SIZE(alc889_capture_sources),
10138                 .input_mux = alc889_capture_sources,
10139                 .unsol_event = alc_automute_amp_unsol_event,
10140                 .setup = alc889_acer_aspire_8930g_setup,
10141                 .init_hook = alc_automute_amp,
10142 #ifdef CONFIG_SND_HDA_POWER_SAVE
10143                 .power_hook = alc_power_eapd,
10144 #endif
10145         },
10146         [ALC888_ACER_ASPIRE_7730G] = {
10147                 .mixers = { alc883_3ST_6ch_mixer,
10148                                 alc883_chmode_mixer },
10149                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
10150                                 alc888_acer_aspire_7730G_verbs },
10151                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10152                 .dac_nids = alc883_dac_nids,
10153                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10154                 .adc_nids = alc883_adc_nids_rev,
10155                 .capsrc_nids = alc883_capsrc_nids_rev,
10156                 .dig_out_nid = ALC883_DIGOUT_NID,
10157                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10158                 .channel_mode = alc883_3ST_6ch_modes,
10159                 .need_dac_fix = 1,
10160                 .const_channel_count = 6,
10161                 .input_mux = &alc883_capture_source,
10162                 .unsol_event = alc_automute_amp_unsol_event,
10163                 .setup = alc888_acer_aspire_6530g_setup,
10164                 .init_hook = alc_automute_amp,
10165         },
10166         [ALC883_MEDION] = {
10167                 .mixers = { alc883_fivestack_mixer,
10168                             alc883_chmode_mixer },
10169                 .init_verbs = { alc883_init_verbs,
10170                                 alc883_medion_eapd_verbs },
10171                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10172                 .dac_nids = alc883_dac_nids,
10173                 .adc_nids = alc883_adc_nids_alt,
10174                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10175                 .capsrc_nids = alc883_capsrc_nids,
10176                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10177                 .channel_mode = alc883_sixstack_modes,
10178                 .input_mux = &alc883_capture_source,
10179         },
10180         [ALC883_MEDION_MD2] = {
10181                 .mixers = { alc883_medion_md2_mixer},
10182                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
10183                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10184                 .dac_nids = alc883_dac_nids,
10185                 .dig_out_nid = ALC883_DIGOUT_NID,
10186                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10187                 .channel_mode = alc883_3ST_2ch_modes,
10188                 .input_mux = &alc883_capture_source,
10189                 .unsol_event = alc_automute_amp_unsol_event,
10190                 .setup = alc883_medion_md2_setup,
10191                 .init_hook = alc_automute_amp,
10192         },
10193         [ALC883_MEDION_WIM2160] = {
10194                 .mixers = { alc883_medion_wim2160_mixer },
10195                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
10196                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10197                 .dac_nids = alc883_dac_nids,
10198                 .dig_out_nid = ALC883_DIGOUT_NID,
10199                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10200                 .adc_nids = alc883_adc_nids,
10201                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10202                 .channel_mode = alc883_3ST_2ch_modes,
10203                 .input_mux = &alc883_capture_source,
10204                 .unsol_event = alc_automute_amp_unsol_event,
10205                 .setup = alc883_medion_wim2160_setup,
10206                 .init_hook = alc_automute_amp,
10207         },
10208         [ALC883_LAPTOP_EAPD] = {
10209                 .mixers = { alc883_base_mixer },
10210                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
10211                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10212                 .dac_nids = alc883_dac_nids,
10213                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10214                 .channel_mode = alc883_3ST_2ch_modes,
10215                 .input_mux = &alc883_capture_source,
10216         },
10217         [ALC883_CLEVO_M540R] = {
10218                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10219                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
10220                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10221                 .dac_nids = alc883_dac_nids,
10222                 .dig_out_nid = ALC883_DIGOUT_NID,
10223                 .dig_in_nid = ALC883_DIGIN_NID,
10224                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
10225                 .channel_mode = alc883_3ST_6ch_clevo_modes,
10226                 .need_dac_fix = 1,
10227                 .input_mux = &alc883_capture_source,
10228                 /* This machine has the hardware HP auto-muting, thus
10229                  * we need no software mute via unsol event
10230                  */
10231         },
10232         [ALC883_CLEVO_M720] = {
10233                 .mixers = { alc883_clevo_m720_mixer },
10234                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
10235                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10236                 .dac_nids = alc883_dac_nids,
10237                 .dig_out_nid = ALC883_DIGOUT_NID,
10238                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10239                 .channel_mode = alc883_3ST_2ch_modes,
10240                 .input_mux = &alc883_capture_source,
10241                 .unsol_event = alc883_clevo_m720_unsol_event,
10242                 .setup = alc883_clevo_m720_setup,
10243                 .init_hook = alc883_clevo_m720_init_hook,
10244         },
10245         [ALC883_LENOVO_101E_2ch] = {
10246                 .mixers = { alc883_lenovo_101e_2ch_mixer},
10247                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
10248                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10249                 .dac_nids = alc883_dac_nids,
10250                 .adc_nids = alc883_adc_nids_alt,
10251                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
10252                 .capsrc_nids = alc883_capsrc_nids,
10253                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10254                 .channel_mode = alc883_3ST_2ch_modes,
10255                 .input_mux = &alc883_lenovo_101e_capture_source,
10256                 .unsol_event = alc883_lenovo_101e_unsol_event,
10257                 .init_hook = alc883_lenovo_101e_all_automute,
10258         },
10259         [ALC883_LENOVO_NB0763] = {
10260                 .mixers = { alc883_lenovo_nb0763_mixer },
10261                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
10262                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10263                 .dac_nids = alc883_dac_nids,
10264                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10265                 .channel_mode = alc883_3ST_2ch_modes,
10266                 .need_dac_fix = 1,
10267                 .input_mux = &alc883_lenovo_nb0763_capture_source,
10268                 .unsol_event = alc_automute_amp_unsol_event,
10269                 .setup = alc883_medion_md2_setup,
10270                 .init_hook = alc_automute_amp,
10271         },
10272         [ALC888_LENOVO_MS7195_DIG] = {
10273                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10274                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
10275                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10276                 .dac_nids = alc883_dac_nids,
10277                 .dig_out_nid = ALC883_DIGOUT_NID,
10278                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10279                 .channel_mode = alc883_3ST_6ch_modes,
10280                 .need_dac_fix = 1,
10281                 .input_mux = &alc883_capture_source,
10282                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
10283                 .init_hook = alc888_lenovo_ms7195_front_automute,
10284         },
10285         [ALC883_HAIER_W66] = {
10286                 .mixers = { alc883_targa_2ch_mixer},
10287                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
10288                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10289                 .dac_nids = alc883_dac_nids,
10290                 .dig_out_nid = ALC883_DIGOUT_NID,
10291                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10292                 .channel_mode = alc883_3ST_2ch_modes,
10293                 .input_mux = &alc883_capture_source,
10294                 .unsol_event = alc_automute_amp_unsol_event,
10295                 .setup = alc883_haier_w66_setup,
10296                 .init_hook = alc_automute_amp,
10297         },
10298         [ALC888_3ST_HP] = {
10299                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10300                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
10301                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10302                 .dac_nids = alc883_dac_nids,
10303                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
10304                 .channel_mode = alc888_3st_hp_modes,
10305                 .need_dac_fix = 1,
10306                 .input_mux = &alc883_capture_source,
10307                 .unsol_event = alc_automute_amp_unsol_event,
10308                 .setup = alc888_3st_hp_setup,
10309                 .init_hook = alc_automute_amp,
10310         },
10311         [ALC888_6ST_DELL] = {
10312                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10313                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
10314                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10315                 .dac_nids = alc883_dac_nids,
10316                 .dig_out_nid = ALC883_DIGOUT_NID,
10317                 .dig_in_nid = ALC883_DIGIN_NID,
10318                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10319                 .channel_mode = alc883_sixstack_modes,
10320                 .input_mux = &alc883_capture_source,
10321                 .unsol_event = alc_automute_amp_unsol_event,
10322                 .setup = alc888_6st_dell_setup,
10323                 .init_hook = alc_automute_amp,
10324         },
10325         [ALC883_MITAC] = {
10326                 .mixers = { alc883_mitac_mixer },
10327                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
10328                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10329                 .dac_nids = alc883_dac_nids,
10330                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10331                 .channel_mode = alc883_3ST_2ch_modes,
10332                 .input_mux = &alc883_capture_source,
10333                 .unsol_event = alc_automute_amp_unsol_event,
10334                 .setup = alc883_mitac_setup,
10335                 .init_hook = alc_automute_amp,
10336         },
10337         [ALC883_FUJITSU_PI2515] = {
10338                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10339                 .init_verbs = { alc883_init_verbs,
10340                                 alc883_2ch_fujitsu_pi2515_verbs},
10341                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10342                 .dac_nids = alc883_dac_nids,
10343                 .dig_out_nid = ALC883_DIGOUT_NID,
10344                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10345                 .channel_mode = alc883_3ST_2ch_modes,
10346                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10347                 .unsol_event = alc_automute_amp_unsol_event,
10348                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10349                 .init_hook = alc_automute_amp,
10350         },
10351         [ALC888_FUJITSU_XA3530] = {
10352                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10353                 .init_verbs = { alc883_init_verbs,
10354                         alc888_fujitsu_xa3530_verbs },
10355                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10356                 .dac_nids = alc883_dac_nids,
10357                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10358                 .adc_nids = alc883_adc_nids_rev,
10359                 .capsrc_nids = alc883_capsrc_nids_rev,
10360                 .dig_out_nid = ALC883_DIGOUT_NID,
10361                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10362                 .channel_mode = alc888_4ST_8ch_intel_modes,
10363                 .num_mux_defs =
10364                         ARRAY_SIZE(alc888_2_capture_sources),
10365                 .input_mux = alc888_2_capture_sources,
10366                 .unsol_event = alc_automute_amp_unsol_event,
10367                 .setup = alc888_fujitsu_xa3530_setup,
10368                 .init_hook = alc_automute_amp,
10369         },
10370         [ALC888_LENOVO_SKY] = {
10371                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10372                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10373                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10374                 .dac_nids = alc883_dac_nids,
10375                 .dig_out_nid = ALC883_DIGOUT_NID,
10376                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10377                 .channel_mode = alc883_sixstack_modes,
10378                 .need_dac_fix = 1,
10379                 .input_mux = &alc883_lenovo_sky_capture_source,
10380                 .unsol_event = alc_automute_amp_unsol_event,
10381                 .setup = alc888_lenovo_sky_setup,
10382                 .init_hook = alc_automute_amp,
10383         },
10384         [ALC888_ASUS_M90V] = {
10385                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10386                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10387                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10388                 .dac_nids = alc883_dac_nids,
10389                 .dig_out_nid = ALC883_DIGOUT_NID,
10390                 .dig_in_nid = ALC883_DIGIN_NID,
10391                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10392                 .channel_mode = alc883_3ST_6ch_modes,
10393                 .need_dac_fix = 1,
10394                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10395                 .unsol_event = alc_sku_unsol_event,
10396                 .setup = alc883_mode2_setup,
10397                 .init_hook = alc_inithook,
10398         },
10399         [ALC888_ASUS_EEE1601] = {
10400                 .mixers = { alc883_asus_eee1601_mixer },
10401                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10402                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10403                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10404                 .dac_nids = alc883_dac_nids,
10405                 .dig_out_nid = ALC883_DIGOUT_NID,
10406                 .dig_in_nid = ALC883_DIGIN_NID,
10407                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10408                 .channel_mode = alc883_3ST_2ch_modes,
10409                 .need_dac_fix = 1,
10410                 .input_mux = &alc883_asus_eee1601_capture_source,
10411                 .unsol_event = alc_sku_unsol_event,
10412                 .init_hook = alc883_eee1601_inithook,
10413         },
10414         [ALC1200_ASUS_P5Q] = {
10415                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10416                 .init_verbs = { alc883_init_verbs },
10417                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10418                 .dac_nids = alc883_dac_nids,
10419                 .dig_out_nid = ALC1200_DIGOUT_NID,
10420                 .dig_in_nid = ALC883_DIGIN_NID,
10421                 .slave_dig_outs = alc1200_slave_dig_outs,
10422                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10423                 .channel_mode = alc883_sixstack_modes,
10424                 .input_mux = &alc883_capture_source,
10425         },
10426         [ALC889A_MB31] = {
10427                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10428                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10429                         alc880_gpio1_init_verbs },
10430                 .adc_nids = alc883_adc_nids,
10431                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10432                 .capsrc_nids = alc883_capsrc_nids,
10433                 .dac_nids = alc883_dac_nids,
10434                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10435                 .channel_mode = alc889A_mb31_6ch_modes,
10436                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10437                 .input_mux = &alc889A_mb31_capture_source,
10438                 .dig_out_nid = ALC883_DIGOUT_NID,
10439                 .unsol_event = alc889A_mb31_unsol_event,
10440                 .init_hook = alc889A_mb31_automute,
10441         },
10442         [ALC883_SONY_VAIO_TT] = {
10443                 .mixers = { alc883_vaiott_mixer },
10444                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10445                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10446                 .dac_nids = alc883_dac_nids,
10447                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10448                 .channel_mode = alc883_3ST_2ch_modes,
10449                 .input_mux = &alc883_capture_source,
10450                 .unsol_event = alc_automute_amp_unsol_event,
10451                 .setup = alc883_vaiott_setup,
10452                 .init_hook = alc_automute_amp,
10453         },
10454 };
10455
10456
10457 /*
10458  * Pin config fixes
10459  */
10460 enum {
10461         PINFIX_ABIT_AW9D_MAX,
10462         PINFIX_PB_M5210,
10463 };
10464
10465 static const struct alc_fixup alc882_fixups[] = {
10466         [PINFIX_ABIT_AW9D_MAX] = {
10467                 .pins = (const struct alc_pincfg[]) {
10468                         { 0x15, 0x01080104 }, /* side */
10469                         { 0x16, 0x01011012 }, /* rear */
10470                         { 0x17, 0x01016011 }, /* clfe */
10471                         { }
10472                 }
10473         },
10474         [PINFIX_PB_M5210] = {
10475                 .verbs = (const struct hda_verb[]) {
10476                         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50 },
10477                         {}
10478                 }
10479         },
10480 };
10481
10482 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10483         SND_PCI_QUIRK(0x1025, 0x0155, "Packard-Bell M5120", PINFIX_PB_M5210),
10484         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10485         {}
10486 };
10487
10488 /*
10489  * BIOS auto configuration
10490  */
10491 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10492                                                 const struct auto_pin_cfg *cfg)
10493 {
10494         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10495 }
10496
10497 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10498                                               hda_nid_t nid, int pin_type,
10499                                               hda_nid_t dac)
10500 {
10501         int idx;
10502
10503         /* set as output */
10504         alc_set_pin_output(codec, nid, pin_type);
10505
10506         if (dac == 0x25)
10507                 idx = 4;
10508         else if (dac >= 0x02 && dac <= 0x05)
10509                 idx = dac - 2;
10510         else
10511                 return;
10512         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10513 }
10514
10515 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10516 {
10517         struct alc_spec *spec = codec->spec;
10518         int i;
10519
10520         for (i = 0; i <= HDA_SIDE; i++) {
10521                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10522                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10523                 if (nid)
10524                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10525                                         spec->multiout.dac_nids[i]);
10526         }
10527 }
10528
10529 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10530 {
10531         struct alc_spec *spec = codec->spec;
10532         hda_nid_t pin, dac;
10533
10534         pin = spec->autocfg.hp_pins[0];
10535         if (pin) {
10536                 dac = spec->multiout.hp_nid;
10537                 if (!dac)
10538                         dac = spec->multiout.dac_nids[0]; /* to front */
10539                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, dac);
10540         }
10541         pin = spec->autocfg.speaker_pins[0];
10542         if (pin) {
10543                 dac = spec->multiout.extra_out_nid[0];
10544                 if (!dac)
10545                         dac = spec->multiout.dac_nids[0]; /* to front */
10546                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, dac);
10547         }
10548 }
10549
10550 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10551 {
10552         struct alc_spec *spec = codec->spec;
10553         struct auto_pin_cfg *cfg = &spec->autocfg;
10554         int i;
10555
10556         for (i = 0; i < cfg->num_inputs; i++) {
10557                 hda_nid_t nid = cfg->inputs[i].pin;
10558                 alc_set_input_pin(codec, nid, i);
10559                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10560                         snd_hda_codec_write(codec, nid, 0,
10561                                             AC_VERB_SET_AMP_GAIN_MUTE,
10562                                             AMP_OUT_MUTE);
10563         }
10564 }
10565
10566 static void alc882_auto_init_input_src(struct hda_codec *codec)
10567 {
10568         struct alc_spec *spec = codec->spec;
10569         int c;
10570
10571         for (c = 0; c < spec->num_adc_nids; c++) {
10572                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10573                 hda_nid_t nid = spec->capsrc_nids[c];
10574                 unsigned int mux_idx;
10575                 const struct hda_input_mux *imux;
10576                 int conns, mute, idx, item;
10577
10578                 conns = snd_hda_get_connections(codec, nid, conn_list,
10579                                                 ARRAY_SIZE(conn_list));
10580                 if (conns < 0)
10581                         continue;
10582                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10583                 imux = &spec->input_mux[mux_idx];
10584                 if (!imux->num_items && mux_idx > 0)
10585                         imux = &spec->input_mux[0];
10586                 for (idx = 0; idx < conns; idx++) {
10587                         /* if the current connection is the selected one,
10588                          * unmute it as default - otherwise mute it
10589                          */
10590                         mute = AMP_IN_MUTE(idx);
10591                         for (item = 0; item < imux->num_items; item++) {
10592                                 if (imux->items[item].index == idx) {
10593                                         if (spec->cur_mux[c] == item)
10594                                                 mute = AMP_IN_UNMUTE(idx);
10595                                         break;
10596                                 }
10597                         }
10598                         /* check if we have a selector or mixer
10599                          * we could check for the widget type instead, but
10600                          * just check for Amp-In presence (in case of mixer
10601                          * without amp-in there is something wrong, this
10602                          * function shouldn't be used or capsrc nid is wrong)
10603                          */
10604                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10605                                 snd_hda_codec_write(codec, nid, 0,
10606                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10607                                                     mute);
10608                         else if (mute != AMP_IN_MUTE(idx))
10609                                 snd_hda_codec_write(codec, nid, 0,
10610                                                     AC_VERB_SET_CONNECT_SEL,
10611                                                     idx);
10612                 }
10613         }
10614 }
10615
10616 /* add mic boosts if needed */
10617 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10618 {
10619         struct alc_spec *spec = codec->spec;
10620         struct auto_pin_cfg *cfg = &spec->autocfg;
10621         int i, err;
10622         hda_nid_t nid;
10623
10624         for (i = 0; i < cfg->num_inputs; i++) {
10625                 if (cfg->inputs[i].type > AUTO_PIN_FRONT_MIC)
10626                         break;
10627                 nid = cfg->inputs[i].pin;
10628                 if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP) {
10629                         char label[32];
10630                         snprintf(label, sizeof(label), "%s Boost",
10631                                  snd_hda_get_input_pin_label(cfg, i));
10632                         err = add_control(spec, ALC_CTL_WIDGET_VOL, label, 0,
10633                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10634                         if (err < 0)
10635                                 return err;
10636                 }
10637         }
10638         return 0;
10639 }
10640
10641 /* almost identical with ALC880 parser... */
10642 static int alc882_parse_auto_config(struct hda_codec *codec)
10643 {
10644         struct alc_spec *spec = codec->spec;
10645         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10646         int err;
10647
10648         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10649                                            alc882_ignore);
10650         if (err < 0)
10651                 return err;
10652         if (!spec->autocfg.line_outs)
10653                 return 0; /* can't find valid BIOS pin config */
10654
10655         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10656         if (err < 0)
10657                 return err;
10658         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10659         if (err < 0)
10660                 return err;
10661         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10662                                            "Headphone");
10663         if (err < 0)
10664                 return err;
10665         err = alc880_auto_create_extra_out(spec,
10666                                            spec->autocfg.speaker_pins[0],
10667                                            "Speaker");
10668         if (err < 0)
10669                 return err;
10670         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10671         if (err < 0)
10672                 return err;
10673
10674         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10675
10676         alc_auto_parse_digital(codec);
10677
10678         if (spec->kctls.list)
10679                 add_mixer(spec, spec->kctls.list);
10680
10681         add_verb(spec, alc883_auto_init_verbs);
10682         /* if ADC 0x07 is available, initialize it, too */
10683         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10684                 add_verb(spec, alc882_adc1_init_verbs);
10685
10686         spec->num_mux_defs = 1;
10687         spec->input_mux = &spec->private_imux[0];
10688
10689         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10690
10691         err = alc_auto_add_mic_boost(codec);
10692         if (err < 0)
10693                 return err;
10694
10695         return 1; /* config found */
10696 }
10697
10698 /* additional initialization for auto-configuration model */
10699 static void alc882_auto_init(struct hda_codec *codec)
10700 {
10701         struct alc_spec *spec = codec->spec;
10702         alc882_auto_init_multi_out(codec);
10703         alc882_auto_init_hp_out(codec);
10704         alc882_auto_init_analog_input(codec);
10705         alc882_auto_init_input_src(codec);
10706         alc_auto_init_digital(codec);
10707         if (spec->unsol_event)
10708                 alc_inithook(codec);
10709 }
10710
10711 static int patch_alc882(struct hda_codec *codec)
10712 {
10713         struct alc_spec *spec;
10714         int err, board_config;
10715
10716         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10717         if (spec == NULL)
10718                 return -ENOMEM;
10719
10720         codec->spec = spec;
10721
10722         alc_auto_parse_customize_define(codec);
10723
10724         switch (codec->vendor_id) {
10725         case 0x10ec0882:
10726         case 0x10ec0885:
10727                 break;
10728         default:
10729                 /* ALC883 and variants */
10730                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10731                 break;
10732         }
10733
10734         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10735                                                   alc882_models,
10736                                                   alc882_cfg_tbl);
10737
10738         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10739                 board_config = snd_hda_check_board_codec_sid_config(codec,
10740                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10741
10742         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10743                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10744                        codec->chip_name);
10745                 board_config = ALC882_AUTO;
10746         }
10747
10748         if (board_config == ALC882_AUTO)
10749                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 1);
10750
10751         if (board_config == ALC882_AUTO) {
10752                 /* automatic parse from the BIOS config */
10753                 err = alc882_parse_auto_config(codec);
10754                 if (err < 0) {
10755                         alc_free(codec);
10756                         return err;
10757                 } else if (!err) {
10758                         printk(KERN_INFO
10759                                "hda_codec: Cannot set up configuration "
10760                                "from BIOS.  Using base mode...\n");
10761                         board_config = ALC882_3ST_DIG;
10762                 }
10763         }
10764
10765         if (has_cdefine_beep(codec)) {
10766                 err = snd_hda_attach_beep_device(codec, 0x1);
10767                 if (err < 0) {
10768                         alc_free(codec);
10769                         return err;
10770                 }
10771         }
10772
10773         if (board_config != ALC882_AUTO)
10774                 setup_preset(codec, &alc882_presets[board_config]);
10775
10776         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10777         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10778         /* FIXME: setup DAC5 */
10779         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10780         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10781
10782         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10783         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10784
10785         if (!spec->adc_nids && spec->input_mux) {
10786                 int i, j;
10787                 spec->num_adc_nids = 0;
10788                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10789                         const struct hda_input_mux *imux = spec->input_mux;
10790                         hda_nid_t cap;
10791                         hda_nid_t items[16];
10792                         hda_nid_t nid = alc882_adc_nids[i];
10793                         unsigned int wcap = get_wcaps(codec, nid);
10794                         /* get type */
10795                         wcap = get_wcaps_type(wcap);
10796                         if (wcap != AC_WID_AUD_IN)
10797                                 continue;
10798                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10799                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10800                         if (err < 0)
10801                                 continue;
10802                         err = snd_hda_get_connections(codec, cap, items,
10803                                                       ARRAY_SIZE(items));
10804                         if (err < 0)
10805                                 continue;
10806                         for (j = 0; j < imux->num_items; j++)
10807                                 if (imux->items[j].index >= err)
10808                                         break;
10809                         if (j < imux->num_items)
10810                                 continue;
10811                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10812                         spec->num_adc_nids++;
10813                 }
10814                 spec->adc_nids = spec->private_adc_nids;
10815                 spec->capsrc_nids = spec->private_capsrc_nids;
10816         }
10817
10818         set_capture_mixer(codec);
10819
10820         if (has_cdefine_beep(codec))
10821                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10822
10823         if (board_config == ALC882_AUTO)
10824                 alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups, 0);
10825
10826         spec->vmaster_nid = 0x0c;
10827
10828         codec->patch_ops = alc_patch_ops;
10829         if (board_config == ALC882_AUTO)
10830                 spec->init_hook = alc882_auto_init;
10831 #ifdef CONFIG_SND_HDA_POWER_SAVE
10832         if (!spec->loopback.amplist)
10833                 spec->loopback.amplist = alc882_loopbacks;
10834 #endif
10835
10836         return 0;
10837 }
10838
10839
10840 /*
10841  * ALC262 support
10842  */
10843
10844 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10845 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10846
10847 #define alc262_dac_nids         alc260_dac_nids
10848 #define alc262_adc_nids         alc882_adc_nids
10849 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10850 #define alc262_capsrc_nids      alc882_capsrc_nids
10851 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10852
10853 #define alc262_modes            alc260_modes
10854 #define alc262_capture_source   alc882_capture_source
10855
10856 static hda_nid_t alc262_dmic_adc_nids[1] = {
10857         /* ADC0 */
10858         0x09
10859 };
10860
10861 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10862
10863 static struct snd_kcontrol_new alc262_base_mixer[] = {
10864         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10865         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10866         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10867         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10868         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10869         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10870         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10871         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10872         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10873         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10874         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10875         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10876         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10877         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10878         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10879         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10880         { } /* end */
10881 };
10882
10883 /* update HP, line and mono-out pins according to the master switch */
10884 static void alc262_hp_master_update(struct hda_codec *codec)
10885 {
10886         struct alc_spec *spec = codec->spec;
10887         int val = spec->master_sw;
10888
10889         /* HP & line-out */
10890         snd_hda_codec_write_cache(codec, 0x1b, 0,
10891                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10892                                   val ? PIN_HP : 0);
10893         snd_hda_codec_write_cache(codec, 0x15, 0,
10894                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10895                                   val ? PIN_HP : 0);
10896         /* mono (speaker) depending on the HP jack sense */
10897         val = val && !spec->jack_present;
10898         snd_hda_codec_write_cache(codec, 0x16, 0,
10899                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10900                                   val ? PIN_OUT : 0);
10901 }
10902
10903 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10904 {
10905         struct alc_spec *spec = codec->spec;
10906
10907         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10908         alc262_hp_master_update(codec);
10909 }
10910
10911 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10912 {
10913         if ((res >> 26) != ALC880_HP_EVENT)
10914                 return;
10915         alc262_hp_bpc_automute(codec);
10916 }
10917
10918 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10919 {
10920         struct alc_spec *spec = codec->spec;
10921
10922         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10923         alc262_hp_master_update(codec);
10924 }
10925
10926 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10927                                            unsigned int res)
10928 {
10929         if ((res >> 26) != ALC880_HP_EVENT)
10930                 return;
10931         alc262_hp_wildwest_automute(codec);
10932 }
10933
10934 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10935
10936 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10937                                    struct snd_ctl_elem_value *ucontrol)
10938 {
10939         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10940         struct alc_spec *spec = codec->spec;
10941         int val = !!*ucontrol->value.integer.value;
10942
10943         if (val == spec->master_sw)
10944                 return 0;
10945         spec->master_sw = val;
10946         alc262_hp_master_update(codec);
10947         return 1;
10948 }
10949
10950 #define ALC262_HP_MASTER_SWITCH                                 \
10951         {                                                       \
10952                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10953                 .name = "Master Playback Switch",               \
10954                 .info = snd_ctl_boolean_mono_info,              \
10955                 .get = alc262_hp_master_sw_get,                 \
10956                 .put = alc262_hp_master_sw_put,                 \
10957         }, \
10958         {                                                       \
10959                 .iface = NID_MAPPING,                           \
10960                 .name = "Master Playback Switch",               \
10961                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
10962         }
10963
10964
10965 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10966         ALC262_HP_MASTER_SWITCH,
10967         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10968         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10969         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10970         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10971                               HDA_OUTPUT),
10972         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10973                             HDA_OUTPUT),
10974         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10976         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10977         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10978         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10979         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10980         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10981         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10982         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10983         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10984         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10985         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10986         { } /* end */
10987 };
10988
10989 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10990         ALC262_HP_MASTER_SWITCH,
10991         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10992         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10993         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10994         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10995         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10996                               HDA_OUTPUT),
10997         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10998                             HDA_OUTPUT),
10999         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
11000         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
11001         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
11002         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11003         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11004         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11005         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11006         { } /* end */
11007 };
11008
11009 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
11010         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11011         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11012         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
11013         { } /* end */
11014 };
11015
11016 /* mute/unmute internal speaker according to the hp jack and mute state */
11017 static void alc262_hp_t5735_setup(struct hda_codec *codec)
11018 {
11019         struct alc_spec *spec = codec->spec;
11020
11021         spec->autocfg.hp_pins[0] = 0x15;
11022         spec->autocfg.speaker_pins[0] = 0x14;
11023 }
11024
11025 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
11026         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11027         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11028         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11029         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11030         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11031         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11032         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11033         { } /* end */
11034 };
11035
11036 static struct hda_verb alc262_hp_t5735_verbs[] = {
11037         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11038         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11039
11040         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11041         { }
11042 };
11043
11044 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
11045         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11046         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
11047         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
11048         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
11049         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
11050         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
11051         { } /* end */
11052 };
11053
11054 static struct hda_verb alc262_hp_rp5700_verbs[] = {
11055         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11056         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11057         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11058         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11059         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11060         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11061         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11062         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11063         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11064         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
11065         {}
11066 };
11067
11068 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
11069         .num_items = 1,
11070         .items = {
11071                 { "Line", 0x1 },
11072         },
11073 };
11074
11075 /* bind hp and internal speaker mute (with plug check) as master switch */
11076 static void alc262_hippo_master_update(struct hda_codec *codec)
11077 {
11078         struct alc_spec *spec = codec->spec;
11079         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11080         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
11081         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
11082         unsigned int mute;
11083
11084         /* HP */
11085         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
11086         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
11087                                  HDA_AMP_MUTE, mute);
11088         /* mute internal speaker per jack sense */
11089         if (spec->jack_present)
11090                 mute = HDA_AMP_MUTE;
11091         if (line_nid)
11092                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
11093                                          HDA_AMP_MUTE, mute);
11094         if (speaker_nid && speaker_nid != line_nid)
11095                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
11096                                          HDA_AMP_MUTE, mute);
11097 }
11098
11099 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
11100
11101 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
11102                                       struct snd_ctl_elem_value *ucontrol)
11103 {
11104         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11105         struct alc_spec *spec = codec->spec;
11106         int val = !!*ucontrol->value.integer.value;
11107
11108         if (val == spec->master_sw)
11109                 return 0;
11110         spec->master_sw = val;
11111         alc262_hippo_master_update(codec);
11112         return 1;
11113 }
11114
11115 #define ALC262_HIPPO_MASTER_SWITCH                              \
11116         {                                                       \
11117                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
11118                 .name = "Master Playback Switch",               \
11119                 .info = snd_ctl_boolean_mono_info,              \
11120                 .get = alc262_hippo_master_sw_get,              \
11121                 .put = alc262_hippo_master_sw_put,              \
11122         },                                                      \
11123         {                                                       \
11124                 .iface = NID_MAPPING,                           \
11125                 .name = "Master Playback Switch",               \
11126                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
11127                              (SUBDEV_SPEAKER(0) << 16), \
11128         }
11129
11130 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
11131         ALC262_HIPPO_MASTER_SWITCH,
11132         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11133         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11134         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11135         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11136         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11137         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11138         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11139         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11140         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11141         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11142         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11143         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11144         { } /* end */
11145 };
11146
11147 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
11148         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11149         ALC262_HIPPO_MASTER_SWITCH,
11150         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11151         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11152         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11153         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11155         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11156         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11157         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11158         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11159         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11160         { } /* end */
11161 };
11162
11163 /* mute/unmute internal speaker according to the hp jack and mute state */
11164 static void alc262_hippo_automute(struct hda_codec *codec)
11165 {
11166         struct alc_spec *spec = codec->spec;
11167         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
11168
11169         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
11170         alc262_hippo_master_update(codec);
11171 }
11172
11173 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
11174 {
11175         if ((res >> 26) != ALC880_HP_EVENT)
11176                 return;
11177         alc262_hippo_automute(codec);
11178 }
11179
11180 static void alc262_hippo_setup(struct hda_codec *codec)
11181 {
11182         struct alc_spec *spec = codec->spec;
11183
11184         spec->autocfg.hp_pins[0] = 0x15;
11185         spec->autocfg.speaker_pins[0] = 0x14;
11186 }
11187
11188 static void alc262_hippo1_setup(struct hda_codec *codec)
11189 {
11190         struct alc_spec *spec = codec->spec;
11191
11192         spec->autocfg.hp_pins[0] = 0x1b;
11193         spec->autocfg.speaker_pins[0] = 0x14;
11194 }
11195
11196
11197 static struct snd_kcontrol_new alc262_sony_mixer[] = {
11198         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11199         ALC262_HIPPO_MASTER_SWITCH,
11200         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11201         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11202         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11203         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11204         { } /* end */
11205 };
11206
11207 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
11208         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11209         ALC262_HIPPO_MASTER_SWITCH,
11210         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11211         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11212         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11213         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11214         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11215         { } /* end */
11216 };
11217
11218 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
11219         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11220         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11221         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
11222         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
11223         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
11224         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
11225         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11226         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11227         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11228         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11229         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11230         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11231         { } /* end */
11232 };
11233
11234 static struct hda_verb alc262_tyan_verbs[] = {
11235         /* Headphone automute */
11236         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11237         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11238         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11239
11240         /* P11 AUX_IN, white 4-pin connector */
11241         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11242         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
11243         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
11244         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
11245
11246         {}
11247 };
11248
11249 /* unsolicited event for HP jack sensing */
11250 static void alc262_tyan_setup(struct hda_codec *codec)
11251 {
11252         struct alc_spec *spec = codec->spec;
11253
11254         spec->autocfg.hp_pins[0] = 0x1b;
11255         spec->autocfg.speaker_pins[0] = 0x15;
11256 }
11257
11258
11259 #define alc262_capture_mixer            alc882_capture_mixer
11260 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
11261
11262 /*
11263  * generic initialization of ADC, input mixers and output mixers
11264  */
11265 static struct hda_verb alc262_init_verbs[] = {
11266         /*
11267          * Unmute ADC0-2 and set the default input to mic-in
11268          */
11269         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11270         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11271         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11272         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11273         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11274         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11275
11276         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11277          * mixer widget
11278          * Note: PASD motherboards uses the Line In 2 as the input for
11279          * front panel mic (mic 2)
11280          */
11281         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11282         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11283         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11284         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11285         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11286         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11287
11288         /*
11289          * Set up output mixers (0x0c - 0x0e)
11290          */
11291         /* set vol=0 to output mixers */
11292         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11293         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11294         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11295         /* set up input amps for analog loopback */
11296         /* Amp Indices: DAC = 0, mixer = 1 */
11297         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11298         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11299         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11300         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11301         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11302         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11303
11304         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11305         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11306         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
11307         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11308         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11309         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11310
11311         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11312         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11313         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11315         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11316
11317         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11318         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11319
11320         /* FIXME: use matrix-type input source selection */
11321         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11322         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11323         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11324         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11325         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11326         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11327         /* Input mixer2 */
11328         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11329         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11330         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11331         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11332         /* Input mixer3 */
11333         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11334         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11335         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11336         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11337
11338         { }
11339 };
11340
11341 static struct hda_verb alc262_eapd_verbs[] = {
11342         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11343         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11344         { }
11345 };
11346
11347 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11348         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11349         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11350         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11351
11352         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11353         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11354         {}
11355 };
11356
11357 static struct hda_verb alc262_sony_unsol_verbs[] = {
11358         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11359         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11360         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11361
11362         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11363         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11364         {}
11365 };
11366
11367 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11368         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11369         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11370         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11371         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11372         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11373         { } /* end */
11374 };
11375
11376 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11377         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11378         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11379         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11380         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11381         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11382         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11383         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11384         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11385         {}
11386 };
11387
11388 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11389 {
11390         struct alc_spec *spec = codec->spec;
11391
11392         spec->autocfg.hp_pins[0] = 0x15;
11393         spec->autocfg.speaker_pins[0] = 0x14;
11394         spec->ext_mic.pin = 0x18;
11395         spec->ext_mic.mux_idx = 0;
11396         spec->int_mic.pin = 0x12;
11397         spec->int_mic.mux_idx = 9;
11398         spec->auto_mic = 1;
11399 }
11400
11401 /*
11402  * nec model
11403  *  0x15 = headphone
11404  *  0x16 = internal speaker
11405  *  0x18 = external mic
11406  */
11407
11408 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11409         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11410         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11411
11412         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11413         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11414         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11415
11416         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11417         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11418         { } /* end */
11419 };
11420
11421 static struct hda_verb alc262_nec_verbs[] = {
11422         /* Unmute Speaker */
11423         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11424
11425         /* Headphone */
11426         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11427         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11428
11429         /* External mic to headphone */
11430         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11431         /* External mic to speaker */
11432         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11433         {}
11434 };
11435
11436 /*
11437  * fujitsu model
11438  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11439  *  0x1b = port replicator headphone out
11440  */
11441
11442 #define ALC_HP_EVENT    0x37
11443
11444 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11445         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11446         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11447         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11448         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11449         {}
11450 };
11451
11452 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11453         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11454         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11455         {}
11456 };
11457
11458 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11459         /* Front Mic pin: input vref at 50% */
11460         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11461         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11462         {}
11463 };
11464
11465 static struct hda_input_mux alc262_fujitsu_capture_source = {
11466         .num_items = 3,
11467         .items = {
11468                 { "Mic", 0x0 },
11469                 { "Int Mic", 0x1 },
11470                 { "CD", 0x4 },
11471         },
11472 };
11473
11474 static struct hda_input_mux alc262_HP_capture_source = {
11475         .num_items = 5,
11476         .items = {
11477                 { "Mic", 0x0 },
11478                 { "Front Mic", 0x1 },
11479                 { "Line", 0x2 },
11480                 { "CD", 0x4 },
11481                 { "AUX IN", 0x6 },
11482         },
11483 };
11484
11485 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11486         .num_items = 4,
11487         .items = {
11488                 { "Mic", 0x0 },
11489                 { "Front Mic", 0x2 },
11490                 { "Line", 0x1 },
11491                 { "CD", 0x4 },
11492         },
11493 };
11494
11495 /* mute/unmute internal speaker according to the hp jacks and mute state */
11496 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11497 {
11498         struct alc_spec *spec = codec->spec;
11499         unsigned int mute;
11500
11501         if (force || !spec->sense_updated) {
11502                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11503                                      snd_hda_jack_detect(codec, 0x1b);
11504                 spec->sense_updated = 1;
11505         }
11506         /* unmute internal speaker only if both HPs are unplugged and
11507          * master switch is on
11508          */
11509         if (spec->jack_present)
11510                 mute = HDA_AMP_MUTE;
11511         else
11512                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11513         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11514                                  HDA_AMP_MUTE, mute);
11515 }
11516
11517 /* unsolicited event for HP jack sensing */
11518 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11519                                        unsigned int res)
11520 {
11521         if ((res >> 26) != ALC_HP_EVENT)
11522                 return;
11523         alc262_fujitsu_automute(codec, 1);
11524 }
11525
11526 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11527 {
11528         alc262_fujitsu_automute(codec, 1);
11529 }
11530
11531 /* bind volumes of both NID 0x0c and 0x0d */
11532 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11533         .ops = &snd_hda_bind_vol,
11534         .values = {
11535                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11536                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11537                 0
11538         },
11539 };
11540
11541 /* mute/unmute internal speaker according to the hp jack and mute state */
11542 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11543 {
11544         struct alc_spec *spec = codec->spec;
11545         unsigned int mute;
11546
11547         if (force || !spec->sense_updated) {
11548                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11549                 spec->sense_updated = 1;
11550         }
11551         if (spec->jack_present) {
11552                 /* mute internal speaker */
11553                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11554                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11555                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11556                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11557         } else {
11558                 /* unmute internal speaker if necessary */
11559                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11560                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11561                                          HDA_AMP_MUTE, mute);
11562                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11563                                          HDA_AMP_MUTE, mute);
11564         }
11565 }
11566
11567 /* unsolicited event for HP jack sensing */
11568 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11569                                        unsigned int res)
11570 {
11571         if ((res >> 26) != ALC_HP_EVENT)
11572                 return;
11573         alc262_lenovo_3000_automute(codec, 1);
11574 }
11575
11576 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11577                                   int dir, int idx, long *valp)
11578 {
11579         int i, change = 0;
11580
11581         for (i = 0; i < 2; i++, valp++)
11582                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11583                                                    HDA_AMP_MUTE,
11584                                                    *valp ? 0 : HDA_AMP_MUTE);
11585         return change;
11586 }
11587
11588 /* bind hp and internal speaker mute (with plug check) */
11589 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11590                                          struct snd_ctl_elem_value *ucontrol)
11591 {
11592         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11593         long *valp = ucontrol->value.integer.value;
11594         int change;
11595
11596         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11597         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11598         if (change)
11599                 alc262_fujitsu_automute(codec, 0);
11600         return change;
11601 }
11602
11603 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11604         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11605         {
11606                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11607                 .name = "Master Playback Switch",
11608                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11609                 .info = snd_hda_mixer_amp_switch_info,
11610                 .get = snd_hda_mixer_amp_switch_get,
11611                 .put = alc262_fujitsu_master_sw_put,
11612                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11613         },
11614         {
11615                 .iface = NID_MAPPING,
11616                 .name = "Master Playback Switch",
11617                 .private_value = 0x1b,
11618         },
11619         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11620         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11621         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11622         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11623         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11624         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11625         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11626         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11627         { } /* end */
11628 };
11629
11630 /* bind hp and internal speaker mute (with plug check) */
11631 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11632                                          struct snd_ctl_elem_value *ucontrol)
11633 {
11634         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11635         long *valp = ucontrol->value.integer.value;
11636         int change;
11637
11638         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11639         if (change)
11640                 alc262_lenovo_3000_automute(codec, 0);
11641         return change;
11642 }
11643
11644 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11645         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11646         {
11647                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11648                 .name = "Master Playback Switch",
11649                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11650                 .info = snd_hda_mixer_amp_switch_info,
11651                 .get = snd_hda_mixer_amp_switch_get,
11652                 .put = alc262_lenovo_3000_master_sw_put,
11653                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11654         },
11655         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11656         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11657         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11658         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11659         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11660         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11661         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11662         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11663         { } /* end */
11664 };
11665
11666 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11667         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11668         ALC262_HIPPO_MASTER_SWITCH,
11669         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11670         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11671         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11672         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11673         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11674         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11675         { } /* end */
11676 };
11677
11678 /* additional init verbs for Benq laptops */
11679 static struct hda_verb alc262_EAPD_verbs[] = {
11680         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11681         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11682         {}
11683 };
11684
11685 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11686         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11687         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11688
11689         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11690         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11691         {}
11692 };
11693
11694 /* Samsung Q1 Ultra Vista model setup */
11695 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11696         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11697         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11698         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11699         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11700         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11701         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11702         { } /* end */
11703 };
11704
11705 static struct hda_verb alc262_ultra_verbs[] = {
11706         /* output mixer */
11707         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11708         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11709         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11710         /* speaker */
11711         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11712         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11713         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11714         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11715         /* HP */
11716         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11717         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11718         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11719         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11720         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11721         /* internal mic */
11722         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11723         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11724         /* ADC, choose mic */
11725         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11726         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11727         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11728         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11729         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11730         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11731         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11732         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11733         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11734         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11735         {}
11736 };
11737
11738 /* mute/unmute internal speaker according to the hp jack and mute state */
11739 static void alc262_ultra_automute(struct hda_codec *codec)
11740 {
11741         struct alc_spec *spec = codec->spec;
11742         unsigned int mute;
11743
11744         mute = 0;
11745         /* auto-mute only when HP is used as HP */
11746         if (!spec->cur_mux[0]) {
11747                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11748                 if (spec->jack_present)
11749                         mute = HDA_AMP_MUTE;
11750         }
11751         /* mute/unmute internal speaker */
11752         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11753                                  HDA_AMP_MUTE, mute);
11754         /* mute/unmute HP */
11755         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11756                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11757 }
11758
11759 /* unsolicited event for HP jack sensing */
11760 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11761                                        unsigned int res)
11762 {
11763         if ((res >> 26) != ALC880_HP_EVENT)
11764                 return;
11765         alc262_ultra_automute(codec);
11766 }
11767
11768 static struct hda_input_mux alc262_ultra_capture_source = {
11769         .num_items = 2,
11770         .items = {
11771                 { "Mic", 0x1 },
11772                 { "Headphone", 0x7 },
11773         },
11774 };
11775
11776 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11777                                      struct snd_ctl_elem_value *ucontrol)
11778 {
11779         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11780         struct alc_spec *spec = codec->spec;
11781         int ret;
11782
11783         ret = alc_mux_enum_put(kcontrol, ucontrol);
11784         if (!ret)
11785                 return 0;
11786         /* reprogram the HP pin as mic or HP according to the input source */
11787         snd_hda_codec_write_cache(codec, 0x15, 0,
11788                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11789                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11790         alc262_ultra_automute(codec); /* mute/unmute HP */
11791         return ret;
11792 }
11793
11794 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11795         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11796         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11797         {
11798                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11799                 .name = "Capture Source",
11800                 .info = alc_mux_enum_info,
11801                 .get = alc_mux_enum_get,
11802                 .put = alc262_ultra_mux_enum_put,
11803         },
11804         {
11805                 .iface = NID_MAPPING,
11806                 .name = "Capture Source",
11807                 .private_value = 0x15,
11808         },
11809         { } /* end */
11810 };
11811
11812 /* We use two mixers depending on the output pin; 0x16 is a mono output
11813  * and thus it's bound with a different mixer.
11814  * This function returns which mixer amp should be used.
11815  */
11816 static int alc262_check_volbit(hda_nid_t nid)
11817 {
11818         if (!nid)
11819                 return 0;
11820         else if (nid == 0x16)
11821                 return 2;
11822         else
11823                 return 1;
11824 }
11825
11826 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11827                                   const char *pfx, int *vbits, int idx)
11828 {
11829         unsigned long val;
11830         int vbit;
11831
11832         vbit = alc262_check_volbit(nid);
11833         if (!vbit)
11834                 return 0;
11835         if (*vbits & vbit) /* a volume control for this mixer already there */
11836                 return 0;
11837         *vbits |= vbit;
11838         if (vbit == 2)
11839                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11840         else
11841                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11842         return __add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, idx, val);
11843 }
11844
11845 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11846                                  const char *pfx, int idx)
11847 {
11848         unsigned long val;
11849
11850         if (!nid)
11851                 return 0;
11852         if (nid == 0x16)
11853                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11854         else
11855                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11856         return __add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, idx, val);
11857 }
11858
11859 /* add playback controls from the parsed DAC table */
11860 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11861                                              const struct auto_pin_cfg *cfg)
11862 {
11863         const char *pfx;
11864         int vbits;
11865         int i, err;
11866
11867         spec->multiout.num_dacs = 1;    /* only use one dac */
11868         spec->multiout.dac_nids = spec->private_dac_nids;
11869         spec->multiout.dac_nids[0] = 2;
11870
11871         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11872                 pfx = "Master";
11873         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11874                 pfx = "Speaker";
11875         else if (cfg->line_out_type == AUTO_PIN_HP_OUT)
11876                 pfx = "Headphone";
11877         else
11878                 pfx = "Front";
11879         for (i = 0; i < 2; i++) {
11880                 err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[i], pfx, i);
11881                 if (err < 0)
11882                         return err;
11883                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
11884                         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[i],
11885                                                     "Speaker", i);
11886                         if (err < 0)
11887                                 return err;
11888                 }
11889                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
11890                         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[i],
11891                                                     "Headphone", i);
11892                         if (err < 0)
11893                                 return err;
11894                 }
11895         }
11896
11897         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11898                 alc262_check_volbit(cfg->speaker_pins[0]) |
11899                 alc262_check_volbit(cfg->hp_pins[0]);
11900         if (vbits == 1 || vbits == 2)
11901                 pfx = "Master"; /* only one mixer is used */
11902         vbits = 0;
11903         for (i = 0; i < 2; i++) {
11904                 err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[i], pfx,
11905                                              &vbits, i);
11906                 if (err < 0)
11907                         return err;
11908                 if (cfg->line_out_type != AUTO_PIN_SPEAKER_OUT) {
11909                         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[i],
11910                                                      "Speaker", &vbits, i);
11911                         if (err < 0)
11912                                 return err;
11913                 }
11914                 if (cfg->line_out_type != AUTO_PIN_HP_OUT) {
11915                         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[i],
11916                                                      "Headphone", &vbits, i);
11917                         if (err < 0)
11918                                 return err;
11919                 }
11920         }
11921         return 0;
11922 }
11923
11924 #define alc262_auto_create_input_ctls \
11925         alc882_auto_create_input_ctls
11926
11927 /*
11928  * generic initialization of ADC, input mixers and output mixers
11929  */
11930 static struct hda_verb alc262_volume_init_verbs[] = {
11931         /*
11932          * Unmute ADC0-2 and set the default input to mic-in
11933          */
11934         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11935         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11936         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11937         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11938         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11939         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11940
11941         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11942          * mixer widget
11943          * Note: PASD motherboards uses the Line In 2 as the input for
11944          * front panel mic (mic 2)
11945          */
11946         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11947         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11948         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11949         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11950         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11951         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11952
11953         /*
11954          * Set up output mixers (0x0c - 0x0f)
11955          */
11956         /* set vol=0 to output mixers */
11957         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11958         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11959         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11960
11961         /* set up input amps for analog loopback */
11962         /* Amp Indices: DAC = 0, mixer = 1 */
11963         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11964         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11965         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11966         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11967         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11968         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11969
11970         /* FIXME: use matrix-type input source selection */
11971         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11972         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11973         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11974         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11975         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11976         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11977         /* Input mixer2 */
11978         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11979         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11980         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11981         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11982         /* Input mixer3 */
11983         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11984         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11985         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11986         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11987
11988         { }
11989 };
11990
11991 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11992         /*
11993          * Unmute ADC0-2 and set the default input to mic-in
11994          */
11995         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11996         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11997         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11998         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11999         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12000         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12001
12002         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12003          * mixer widget
12004          * Note: PASD motherboards uses the Line In 2 as the input for
12005          * front panel mic (mic 2)
12006          */
12007         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12008         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12009         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12010         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12011         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12012         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12013         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12014         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12015
12016         /*
12017          * Set up output mixers (0x0c - 0x0e)
12018          */
12019         /* set vol=0 to output mixers */
12020         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12021         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12022         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12023
12024         /* set up input amps for analog loopback */
12025         /* Amp Indices: DAC = 0, mixer = 1 */
12026         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12027         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12028         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12029         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12030         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12031         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12032
12033         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12034         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12035         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
12036
12037         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12038         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12039
12040         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12041         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12042
12043         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12044         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12045         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12046         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12047         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12048
12049         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12050         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12051         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12052         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12053         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12054         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12055
12056
12057         /* FIXME: use matrix-type input source selection */
12058         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
12059         /* Input mixer1: only unmute Mic */
12060         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12061         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12062         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12063         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12064         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12065         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12066         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12067         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12068         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12069         /* Input mixer2 */
12070         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12071         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12072         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12073         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12074         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12075         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12076         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12077         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12078         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12079         /* Input mixer3 */
12080         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12081         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
12082         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
12083         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
12084         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
12085         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
12086         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
12087         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
12088         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
12089
12090         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12091
12092         { }
12093 };
12094
12095 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
12096         /*
12097          * Unmute ADC0-2 and set the default input to mic-in
12098          */
12099         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
12100         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12101         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
12102         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12103         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
12104         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12105
12106         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
12107          * mixer widget
12108          * Note: PASD motherboards uses the Line In 2 as the input for front
12109          * panel mic (mic 2)
12110          */
12111         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
12112         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
12113         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12114         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
12115         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
12116         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
12117         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
12118         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
12119         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
12120         /*
12121          * Set up output mixers (0x0c - 0x0e)
12122          */
12123         /* set vol=0 to output mixers */
12124         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12125         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12126         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12127
12128         /* set up input amps for analog loopback */
12129         /* Amp Indices: DAC = 0, mixer = 1 */
12130         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12131         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12132         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12133         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12134         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12135         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
12136
12137
12138         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
12139         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
12140         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
12141         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
12142         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12143         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
12144         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
12145
12146         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12147         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12148
12149         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
12150         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
12151
12152         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
12153         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12154         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12155         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
12156         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12157         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
12158
12159         /* FIXME: use matrix-type input source selection */
12160         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
12161         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
12162         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
12163         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
12164         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
12165         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
12166         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
12167         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
12168         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
12169         /* Input mixer2 */
12170         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12171         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12172         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12173         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12174         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12175         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12176         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12177         /* Input mixer3 */
12178         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
12179         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
12180         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
12181         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
12182         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
12183         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
12184         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
12185
12186         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12187
12188         { }
12189 };
12190
12191 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
12192
12193         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
12194         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
12195         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
12196
12197         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
12198         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
12199         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12200         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
12201
12202         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
12203         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
12204         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
12205         {}
12206 };
12207
12208
12209 #ifdef CONFIG_SND_HDA_POWER_SAVE
12210 #define alc262_loopbacks        alc880_loopbacks
12211 #endif
12212
12213 /* pcm configuration: identical with ALC880 */
12214 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
12215 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
12216 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
12217 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
12218
12219 /*
12220  * BIOS auto configuration
12221  */
12222 static int alc262_parse_auto_config(struct hda_codec *codec)
12223 {
12224         struct alc_spec *spec = codec->spec;
12225         int err;
12226         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
12227
12228         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12229                                            alc262_ignore);
12230         if (err < 0)
12231                 return err;
12232         if (!spec->autocfg.line_outs) {
12233                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12234                         spec->multiout.max_channels = 2;
12235                         spec->no_analog = 1;
12236                         goto dig_only;
12237                 }
12238                 return 0; /* can't find valid BIOS pin config */
12239         }
12240         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
12241         if (err < 0)
12242                 return err;
12243         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
12244         if (err < 0)
12245                 return err;
12246
12247         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
12248
12249  dig_only:
12250         alc_auto_parse_digital(codec);
12251
12252         if (spec->kctls.list)
12253                 add_mixer(spec, spec->kctls.list);
12254
12255         add_verb(spec, alc262_volume_init_verbs);
12256         spec->num_mux_defs = 1;
12257         spec->input_mux = &spec->private_imux[0];
12258
12259         err = alc_auto_add_mic_boost(codec);
12260         if (err < 0)
12261                 return err;
12262
12263         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
12264
12265         return 1;
12266 }
12267
12268 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
12269 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
12270 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
12271 #define alc262_auto_init_input_src      alc882_auto_init_input_src
12272
12273
12274 /* init callback for auto-configuration model -- overriding the default init */
12275 static void alc262_auto_init(struct hda_codec *codec)
12276 {
12277         struct alc_spec *spec = codec->spec;
12278         alc262_auto_init_multi_out(codec);
12279         alc262_auto_init_hp_out(codec);
12280         alc262_auto_init_analog_input(codec);
12281         alc262_auto_init_input_src(codec);
12282         alc_auto_init_digital(codec);
12283         if (spec->unsol_event)
12284                 alc_inithook(codec);
12285 }
12286
12287 /*
12288  * configuration and preset
12289  */
12290 static const char *alc262_models[ALC262_MODEL_LAST] = {
12291         [ALC262_BASIC]          = "basic",
12292         [ALC262_HIPPO]          = "hippo",
12293         [ALC262_HIPPO_1]        = "hippo_1",
12294         [ALC262_FUJITSU]        = "fujitsu",
12295         [ALC262_HP_BPC]         = "hp-bpc",
12296         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
12297         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
12298         [ALC262_HP_RP5700]      = "hp-rp5700",
12299         [ALC262_BENQ_ED8]       = "benq",
12300         [ALC262_BENQ_T31]       = "benq-t31",
12301         [ALC262_SONY_ASSAMD]    = "sony-assamd",
12302         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
12303         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
12304         [ALC262_ULTRA]          = "ultra",
12305         [ALC262_LENOVO_3000]    = "lenovo-3000",
12306         [ALC262_NEC]            = "nec",
12307         [ALC262_TYAN]           = "tyan",
12308         [ALC262_AUTO]           = "auto",
12309 };
12310
12311 static struct snd_pci_quirk alc262_cfg_tbl[] = {
12312         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
12313         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
12314         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
12315                            ALC262_HP_BPC),
12316         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
12317                            ALC262_HP_BPC),
12318         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
12319                            ALC262_HP_BPC),
12320         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
12321         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
12322         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
12323         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
12324         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
12325         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
12326         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
12327         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
12328         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
12329         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
12330         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
12331         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
12332                       ALC262_HP_TC_T5735),
12333         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
12334         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12335         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
12336         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
12337         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
12338         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
12339         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
12340         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
12341 #if 0 /* disable the quirk since model=auto works better in recent versions */
12342         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12343                            ALC262_SONY_ASSAMD),
12344 #endif
12345         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12346                       ALC262_TOSHIBA_RX1),
12347         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12348         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12349         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12350         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12351         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12352                            ALC262_ULTRA),
12353         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12354         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12355         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12356         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12357         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12358         {}
12359 };
12360
12361 static struct alc_config_preset alc262_presets[] = {
12362         [ALC262_BASIC] = {
12363                 .mixers = { alc262_base_mixer },
12364                 .init_verbs = { alc262_init_verbs },
12365                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12366                 .dac_nids = alc262_dac_nids,
12367                 .hp_nid = 0x03,
12368                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12369                 .channel_mode = alc262_modes,
12370                 .input_mux = &alc262_capture_source,
12371         },
12372         [ALC262_HIPPO] = {
12373                 .mixers = { alc262_hippo_mixer },
12374                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12375                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12376                 .dac_nids = alc262_dac_nids,
12377                 .hp_nid = 0x03,
12378                 .dig_out_nid = ALC262_DIGOUT_NID,
12379                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12380                 .channel_mode = alc262_modes,
12381                 .input_mux = &alc262_capture_source,
12382                 .unsol_event = alc262_hippo_unsol_event,
12383                 .setup = alc262_hippo_setup,
12384                 .init_hook = alc262_hippo_automute,
12385         },
12386         [ALC262_HIPPO_1] = {
12387                 .mixers = { alc262_hippo1_mixer },
12388                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12389                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12390                 .dac_nids = alc262_dac_nids,
12391                 .hp_nid = 0x02,
12392                 .dig_out_nid = ALC262_DIGOUT_NID,
12393                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12394                 .channel_mode = alc262_modes,
12395                 .input_mux = &alc262_capture_source,
12396                 .unsol_event = alc262_hippo_unsol_event,
12397                 .setup = alc262_hippo1_setup,
12398                 .init_hook = alc262_hippo_automute,
12399         },
12400         [ALC262_FUJITSU] = {
12401                 .mixers = { alc262_fujitsu_mixer },
12402                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12403                                 alc262_fujitsu_unsol_verbs },
12404                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12405                 .dac_nids = alc262_dac_nids,
12406                 .hp_nid = 0x03,
12407                 .dig_out_nid = ALC262_DIGOUT_NID,
12408                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12409                 .channel_mode = alc262_modes,
12410                 .input_mux = &alc262_fujitsu_capture_source,
12411                 .unsol_event = alc262_fujitsu_unsol_event,
12412                 .init_hook = alc262_fujitsu_init_hook,
12413         },
12414         [ALC262_HP_BPC] = {
12415                 .mixers = { alc262_HP_BPC_mixer },
12416                 .init_verbs = { alc262_HP_BPC_init_verbs },
12417                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12418                 .dac_nids = alc262_dac_nids,
12419                 .hp_nid = 0x03,
12420                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12421                 .channel_mode = alc262_modes,
12422                 .input_mux = &alc262_HP_capture_source,
12423                 .unsol_event = alc262_hp_bpc_unsol_event,
12424                 .init_hook = alc262_hp_bpc_automute,
12425         },
12426         [ALC262_HP_BPC_D7000_WF] = {
12427                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12428                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12429                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12430                 .dac_nids = alc262_dac_nids,
12431                 .hp_nid = 0x03,
12432                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12433                 .channel_mode = alc262_modes,
12434                 .input_mux = &alc262_HP_D7000_capture_source,
12435                 .unsol_event = alc262_hp_wildwest_unsol_event,
12436                 .init_hook = alc262_hp_wildwest_automute,
12437         },
12438         [ALC262_HP_BPC_D7000_WL] = {
12439                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12440                             alc262_HP_BPC_WildWest_option_mixer },
12441                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12442                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12443                 .dac_nids = alc262_dac_nids,
12444                 .hp_nid = 0x03,
12445                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12446                 .channel_mode = alc262_modes,
12447                 .input_mux = &alc262_HP_D7000_capture_source,
12448                 .unsol_event = alc262_hp_wildwest_unsol_event,
12449                 .init_hook = alc262_hp_wildwest_automute,
12450         },
12451         [ALC262_HP_TC_T5735] = {
12452                 .mixers = { alc262_hp_t5735_mixer },
12453                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12454                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12455                 .dac_nids = alc262_dac_nids,
12456                 .hp_nid = 0x03,
12457                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12458                 .channel_mode = alc262_modes,
12459                 .input_mux = &alc262_capture_source,
12460                 .unsol_event = alc_sku_unsol_event,
12461                 .setup = alc262_hp_t5735_setup,
12462                 .init_hook = alc_inithook,
12463         },
12464         [ALC262_HP_RP5700] = {
12465                 .mixers = { alc262_hp_rp5700_mixer },
12466                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12467                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12468                 .dac_nids = alc262_dac_nids,
12469                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12470                 .channel_mode = alc262_modes,
12471                 .input_mux = &alc262_hp_rp5700_capture_source,
12472         },
12473         [ALC262_BENQ_ED8] = {
12474                 .mixers = { alc262_base_mixer },
12475                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12476                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12477                 .dac_nids = alc262_dac_nids,
12478                 .hp_nid = 0x03,
12479                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12480                 .channel_mode = alc262_modes,
12481                 .input_mux = &alc262_capture_source,
12482         },
12483         [ALC262_SONY_ASSAMD] = {
12484                 .mixers = { alc262_sony_mixer },
12485                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12486                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12487                 .dac_nids = alc262_dac_nids,
12488                 .hp_nid = 0x02,
12489                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12490                 .channel_mode = alc262_modes,
12491                 .input_mux = &alc262_capture_source,
12492                 .unsol_event = alc262_hippo_unsol_event,
12493                 .setup = alc262_hippo_setup,
12494                 .init_hook = alc262_hippo_automute,
12495         },
12496         [ALC262_BENQ_T31] = {
12497                 .mixers = { alc262_benq_t31_mixer },
12498                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12499                                 alc_hp15_unsol_verbs },
12500                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12501                 .dac_nids = alc262_dac_nids,
12502                 .hp_nid = 0x03,
12503                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12504                 .channel_mode = alc262_modes,
12505                 .input_mux = &alc262_capture_source,
12506                 .unsol_event = alc262_hippo_unsol_event,
12507                 .setup = alc262_hippo_setup,
12508                 .init_hook = alc262_hippo_automute,
12509         },
12510         [ALC262_ULTRA] = {
12511                 .mixers = { alc262_ultra_mixer },
12512                 .cap_mixer = alc262_ultra_capture_mixer,
12513                 .init_verbs = { alc262_ultra_verbs },
12514                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12515                 .dac_nids = alc262_dac_nids,
12516                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12517                 .channel_mode = alc262_modes,
12518                 .input_mux = &alc262_ultra_capture_source,
12519                 .adc_nids = alc262_adc_nids, /* ADC0 */
12520                 .capsrc_nids = alc262_capsrc_nids,
12521                 .num_adc_nids = 1, /* single ADC */
12522                 .unsol_event = alc262_ultra_unsol_event,
12523                 .init_hook = alc262_ultra_automute,
12524         },
12525         [ALC262_LENOVO_3000] = {
12526                 .mixers = { alc262_lenovo_3000_mixer },
12527                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12528                                 alc262_lenovo_3000_unsol_verbs,
12529                                 alc262_lenovo_3000_init_verbs },
12530                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12531                 .dac_nids = alc262_dac_nids,
12532                 .hp_nid = 0x03,
12533                 .dig_out_nid = ALC262_DIGOUT_NID,
12534                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12535                 .channel_mode = alc262_modes,
12536                 .input_mux = &alc262_fujitsu_capture_source,
12537                 .unsol_event = alc262_lenovo_3000_unsol_event,
12538         },
12539         [ALC262_NEC] = {
12540                 .mixers = { alc262_nec_mixer },
12541                 .init_verbs = { alc262_nec_verbs },
12542                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12543                 .dac_nids = alc262_dac_nids,
12544                 .hp_nid = 0x03,
12545                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12546                 .channel_mode = alc262_modes,
12547                 .input_mux = &alc262_capture_source,
12548         },
12549         [ALC262_TOSHIBA_S06] = {
12550                 .mixers = { alc262_toshiba_s06_mixer },
12551                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12552                                                         alc262_eapd_verbs },
12553                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12554                 .capsrc_nids = alc262_dmic_capsrc_nids,
12555                 .dac_nids = alc262_dac_nids,
12556                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12557                 .num_adc_nids = 1, /* single ADC */
12558                 .dig_out_nid = ALC262_DIGOUT_NID,
12559                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12560                 .channel_mode = alc262_modes,
12561                 .unsol_event = alc_sku_unsol_event,
12562                 .setup = alc262_toshiba_s06_setup,
12563                 .init_hook = alc_inithook,
12564         },
12565         [ALC262_TOSHIBA_RX1] = {
12566                 .mixers = { alc262_toshiba_rx1_mixer },
12567                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12568                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12569                 .dac_nids = alc262_dac_nids,
12570                 .hp_nid = 0x03,
12571                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12572                 .channel_mode = alc262_modes,
12573                 .input_mux = &alc262_capture_source,
12574                 .unsol_event = alc262_hippo_unsol_event,
12575                 .setup = alc262_hippo_setup,
12576                 .init_hook = alc262_hippo_automute,
12577         },
12578         [ALC262_TYAN] = {
12579                 .mixers = { alc262_tyan_mixer },
12580                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12581                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12582                 .dac_nids = alc262_dac_nids,
12583                 .hp_nid = 0x02,
12584                 .dig_out_nid = ALC262_DIGOUT_NID,
12585                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12586                 .channel_mode = alc262_modes,
12587                 .input_mux = &alc262_capture_source,
12588                 .unsol_event = alc_automute_amp_unsol_event,
12589                 .setup = alc262_tyan_setup,
12590                 .init_hook = alc_automute_amp,
12591         },
12592 };
12593
12594 static int patch_alc262(struct hda_codec *codec)
12595 {
12596         struct alc_spec *spec;
12597         int board_config;
12598         int err;
12599
12600         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12601         if (spec == NULL)
12602                 return -ENOMEM;
12603
12604         codec->spec = spec;
12605 #if 0
12606         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12607          * under-run
12608          */
12609         {
12610         int tmp;
12611         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12612         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12613         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12614         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12615         }
12616 #endif
12617         alc_auto_parse_customize_define(codec);
12618
12619         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12620
12621         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12622                                                   alc262_models,
12623                                                   alc262_cfg_tbl);
12624
12625         if (board_config < 0) {
12626                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12627                        codec->chip_name);
12628                 board_config = ALC262_AUTO;
12629         }
12630
12631         if (board_config == ALC262_AUTO) {
12632                 /* automatic parse from the BIOS config */
12633                 err = alc262_parse_auto_config(codec);
12634                 if (err < 0) {
12635                         alc_free(codec);
12636                         return err;
12637                 } else if (!err) {
12638                         printk(KERN_INFO
12639                                "hda_codec: Cannot set up configuration "
12640                                "from BIOS.  Using base mode...\n");
12641                         board_config = ALC262_BASIC;
12642                 }
12643         }
12644
12645         if (!spec->no_analog && has_cdefine_beep(codec)) {
12646                 err = snd_hda_attach_beep_device(codec, 0x1);
12647                 if (err < 0) {
12648                         alc_free(codec);
12649                         return err;
12650                 }
12651         }
12652
12653         if (board_config != ALC262_AUTO)
12654                 setup_preset(codec, &alc262_presets[board_config]);
12655
12656         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12657         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12658
12659         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12660         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12661
12662         if (!spec->adc_nids && spec->input_mux) {
12663                 int i;
12664                 /* check whether the digital-mic has to be supported */
12665                 for (i = 0; i < spec->input_mux->num_items; i++) {
12666                         if (spec->input_mux->items[i].index >= 9)
12667                                 break;
12668                 }
12669                 if (i < spec->input_mux->num_items) {
12670                         /* use only ADC0 */
12671                         spec->adc_nids = alc262_dmic_adc_nids;
12672                         spec->num_adc_nids = 1;
12673                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12674                 } else {
12675                         /* all analog inputs */
12676                         /* check whether NID 0x07 is valid */
12677                         unsigned int wcap = get_wcaps(codec, 0x07);
12678
12679                         /* get type */
12680                         wcap = get_wcaps_type(wcap);
12681                         if (wcap != AC_WID_AUD_IN) {
12682                                 spec->adc_nids = alc262_adc_nids_alt;
12683                                 spec->num_adc_nids =
12684                                         ARRAY_SIZE(alc262_adc_nids_alt);
12685                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12686                         } else {
12687                                 spec->adc_nids = alc262_adc_nids;
12688                                 spec->num_adc_nids =
12689                                         ARRAY_SIZE(alc262_adc_nids);
12690                                 spec->capsrc_nids = alc262_capsrc_nids;
12691                         }
12692                 }
12693         }
12694         if (!spec->cap_mixer && !spec->no_analog)
12695                 set_capture_mixer(codec);
12696         if (!spec->no_analog && has_cdefine_beep(codec))
12697                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12698
12699         spec->vmaster_nid = 0x0c;
12700
12701         codec->patch_ops = alc_patch_ops;
12702         if (board_config == ALC262_AUTO)
12703                 spec->init_hook = alc262_auto_init;
12704 #ifdef CONFIG_SND_HDA_POWER_SAVE
12705         if (!spec->loopback.amplist)
12706                 spec->loopback.amplist = alc262_loopbacks;
12707 #endif
12708
12709         return 0;
12710 }
12711
12712 /*
12713  *  ALC268 channel source setting (2 channel)
12714  */
12715 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12716 #define alc268_modes            alc260_modes
12717
12718 static hda_nid_t alc268_dac_nids[2] = {
12719         /* front, hp */
12720         0x02, 0x03
12721 };
12722
12723 static hda_nid_t alc268_adc_nids[2] = {
12724         /* ADC0-1 */
12725         0x08, 0x07
12726 };
12727
12728 static hda_nid_t alc268_adc_nids_alt[1] = {
12729         /* ADC0 */
12730         0x08
12731 };
12732
12733 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12734
12735 static struct snd_kcontrol_new alc268_base_mixer[] = {
12736         /* output mixer control */
12737         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12738         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12739         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12740         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12741         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12742         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12743         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12744         { }
12745 };
12746
12747 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12748         /* output mixer control */
12749         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12750         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12751         ALC262_HIPPO_MASTER_SWITCH,
12752         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12753         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12754         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12755         { }
12756 };
12757
12758 /* bind Beep switches of both NID 0x0f and 0x10 */
12759 static struct hda_bind_ctls alc268_bind_beep_sw = {
12760         .ops = &snd_hda_bind_sw,
12761         .values = {
12762                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12763                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12764                 0
12765         },
12766 };
12767
12768 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12769         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12770         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12771         { }
12772 };
12773
12774 static struct hda_verb alc268_eapd_verbs[] = {
12775         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12776         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12777         { }
12778 };
12779
12780 /* Toshiba specific */
12781 static struct hda_verb alc268_toshiba_verbs[] = {
12782         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12783         { } /* end */
12784 };
12785
12786 /* Acer specific */
12787 /* bind volumes of both NID 0x02 and 0x03 */
12788 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12789         .ops = &snd_hda_bind_vol,
12790         .values = {
12791                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12792                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12793                 0
12794         },
12795 };
12796
12797 /* mute/unmute internal speaker according to the hp jack and mute state */
12798 static void alc268_acer_automute(struct hda_codec *codec, int force)
12799 {
12800         struct alc_spec *spec = codec->spec;
12801         unsigned int mute;
12802
12803         if (force || !spec->sense_updated) {
12804                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12805                 spec->sense_updated = 1;
12806         }
12807         if (spec->jack_present)
12808                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12809         else /* unmute internal speaker if necessary */
12810                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12811         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12812                                  HDA_AMP_MUTE, mute);
12813 }
12814
12815
12816 /* bind hp and internal speaker mute (with plug check) */
12817 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12818                                      struct snd_ctl_elem_value *ucontrol)
12819 {
12820         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12821         long *valp = ucontrol->value.integer.value;
12822         int change;
12823
12824         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12825         if (change)
12826                 alc268_acer_automute(codec, 0);
12827         return change;
12828 }
12829
12830 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12831         /* output mixer control */
12832         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12833         {
12834                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12835                 .name = "Master Playback Switch",
12836                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12837                 .info = snd_hda_mixer_amp_switch_info,
12838                 .get = snd_hda_mixer_amp_switch_get,
12839                 .put = alc268_acer_master_sw_put,
12840                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12841         },
12842         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12843         { }
12844 };
12845
12846 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12847         /* output mixer control */
12848         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12849         {
12850                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12851                 .name = "Master Playback Switch",
12852                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12853                 .info = snd_hda_mixer_amp_switch_info,
12854                 .get = snd_hda_mixer_amp_switch_get,
12855                 .put = alc268_acer_master_sw_put,
12856                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12857         },
12858         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12859         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12860         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12861         { }
12862 };
12863
12864 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12865         /* output mixer control */
12866         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12867         {
12868                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12869                 .name = "Master Playback Switch",
12870                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12871                 .info = snd_hda_mixer_amp_switch_info,
12872                 .get = snd_hda_mixer_amp_switch_get,
12873                 .put = alc268_acer_master_sw_put,
12874                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12875         },
12876         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12877         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12878         { }
12879 };
12880
12881 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12882         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12883         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12884         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12885         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12886         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12887         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12888         { }
12889 };
12890
12891 static struct hda_verb alc268_acer_verbs[] = {
12892         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12893         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12894         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12895         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12896         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12897         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12898         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12899         { }
12900 };
12901
12902 /* unsolicited event for HP jack sensing */
12903 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12904 #define alc268_toshiba_setup            alc262_hippo_setup
12905 #define alc268_toshiba_automute         alc262_hippo_automute
12906
12907 static void alc268_acer_unsol_event(struct hda_codec *codec,
12908                                        unsigned int res)
12909 {
12910         if ((res >> 26) != ALC880_HP_EVENT)
12911                 return;
12912         alc268_acer_automute(codec, 1);
12913 }
12914
12915 static void alc268_acer_init_hook(struct hda_codec *codec)
12916 {
12917         alc268_acer_automute(codec, 1);
12918 }
12919
12920 /* toggle speaker-output according to the hp-jack state */
12921 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12922 {
12923         unsigned int present;
12924         unsigned char bits;
12925
12926         present = snd_hda_jack_detect(codec, 0x15);
12927         bits = present ? HDA_AMP_MUTE : 0;
12928         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12929                                  HDA_AMP_MUTE, bits);
12930         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12931                                  HDA_AMP_MUTE, bits);
12932 }
12933
12934 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12935                                     unsigned int res)
12936 {
12937         switch (res >> 26) {
12938         case ALC880_HP_EVENT:
12939                 alc268_aspire_one_speaker_automute(codec);
12940                 break;
12941         case ALC880_MIC_EVENT:
12942                 alc_mic_automute(codec);
12943                 break;
12944         }
12945 }
12946
12947 static void alc268_acer_lc_setup(struct hda_codec *codec)
12948 {
12949         struct alc_spec *spec = codec->spec;
12950         spec->ext_mic.pin = 0x18;
12951         spec->ext_mic.mux_idx = 0;
12952         spec->int_mic.pin = 0x12;
12953         spec->int_mic.mux_idx = 6;
12954         spec->auto_mic = 1;
12955 }
12956
12957 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12958 {
12959         alc268_aspire_one_speaker_automute(codec);
12960         alc_mic_automute(codec);
12961 }
12962
12963 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12964         /* output mixer control */
12965         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12966         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12967         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12968         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12969         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12970         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12971         { }
12972 };
12973
12974 static struct hda_verb alc268_dell_verbs[] = {
12975         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12976         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12977         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12978         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12979         { }
12980 };
12981
12982 /* mute/unmute internal speaker according to the hp jack and mute state */
12983 static void alc268_dell_setup(struct hda_codec *codec)
12984 {
12985         struct alc_spec *spec = codec->spec;
12986
12987         spec->autocfg.hp_pins[0] = 0x15;
12988         spec->autocfg.speaker_pins[0] = 0x14;
12989         spec->ext_mic.pin = 0x18;
12990         spec->ext_mic.mux_idx = 0;
12991         spec->int_mic.pin = 0x19;
12992         spec->int_mic.mux_idx = 1;
12993         spec->auto_mic = 1;
12994 }
12995
12996 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12997         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12998         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12999         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
13000         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13001         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13002         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
13003         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
13004         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
13005         { }
13006 };
13007
13008 static struct hda_verb alc267_quanta_il1_verbs[] = {
13009         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13010         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
13011         { }
13012 };
13013
13014 static void alc267_quanta_il1_setup(struct hda_codec *codec)
13015 {
13016         struct alc_spec *spec = codec->spec;
13017         spec->autocfg.hp_pins[0] = 0x15;
13018         spec->autocfg.speaker_pins[0] = 0x14;
13019         spec->ext_mic.pin = 0x18;
13020         spec->ext_mic.mux_idx = 0;
13021         spec->int_mic.pin = 0x19;
13022         spec->int_mic.mux_idx = 1;
13023         spec->auto_mic = 1;
13024 }
13025
13026 /*
13027  * generic initialization of ADC, input mixers and output mixers
13028  */
13029 static struct hda_verb alc268_base_init_verbs[] = {
13030         /* Unmute DAC0-1 and set vol = 0 */
13031         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13032         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13033
13034         /*
13035          * Set up output mixers (0x0c - 0x0e)
13036          */
13037         /* set vol=0 to output mixers */
13038         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13039         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
13040
13041         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13042         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13043
13044         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13045         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
13046         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
13047         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13048         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13049         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13050         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13051         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13052
13053         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13054         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13055         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13056         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13057         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13058
13059         /* set PCBEEP vol = 0, mute connections */
13060         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13061         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13062         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13063
13064         /* Unmute Selector 23h,24h and set the default input to mic-in */
13065
13066         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13067         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13068         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
13069         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13070
13071         { }
13072 };
13073
13074 /*
13075  * generic initialization of ADC, input mixers and output mixers
13076  */
13077 static struct hda_verb alc268_volume_init_verbs[] = {
13078         /* set output DAC */
13079         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13080         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13081
13082         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13083         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
13084         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13085         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13086         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
13087
13088         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13089         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13090         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13091
13092         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13093         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13094
13095         /* set PCBEEP vol = 0, mute connections */
13096         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13097         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13098         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13099
13100         { }
13101 };
13102
13103 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
13104         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13105         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13106         { } /* end */
13107 };
13108
13109 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
13110         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13111         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13112         _DEFINE_CAPSRC(1),
13113         { } /* end */
13114 };
13115
13116 static struct snd_kcontrol_new alc268_capture_mixer[] = {
13117         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13118         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
13119         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
13120         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
13121         _DEFINE_CAPSRC(2),
13122         { } /* end */
13123 };
13124
13125 static struct hda_input_mux alc268_capture_source = {
13126         .num_items = 4,
13127         .items = {
13128                 { "Mic", 0x0 },
13129                 { "Front Mic", 0x1 },
13130                 { "Line", 0x2 },
13131                 { "CD", 0x3 },
13132         },
13133 };
13134
13135 static struct hda_input_mux alc268_acer_capture_source = {
13136         .num_items = 3,
13137         .items = {
13138                 { "Mic", 0x0 },
13139                 { "Internal Mic", 0x1 },
13140                 { "Line", 0x2 },
13141         },
13142 };
13143
13144 static struct hda_input_mux alc268_acer_dmic_capture_source = {
13145         .num_items = 3,
13146         .items = {
13147                 { "Mic", 0x0 },
13148                 { "Internal Mic", 0x6 },
13149                 { "Line", 0x2 },
13150         },
13151 };
13152
13153 #ifdef CONFIG_SND_DEBUG
13154 static struct snd_kcontrol_new alc268_test_mixer[] = {
13155         /* Volume widgets */
13156         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13157         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13158         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
13159         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
13160         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
13161         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
13162         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
13163         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
13164         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
13165         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
13166         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
13167         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
13168         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
13169         /* The below appears problematic on some hardwares */
13170         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
13171         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
13172         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
13173         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
13174         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
13175
13176         /* Modes for retasking pin widgets */
13177         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
13178         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
13179         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
13180         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
13181
13182         /* Controls for GPIO pins, assuming they are configured as outputs */
13183         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
13184         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
13185         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
13186         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
13187
13188         /* Switches to allow the digital SPDIF output pin to be enabled.
13189          * The ALC268 does not have an SPDIF input.
13190          */
13191         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
13192
13193         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
13194          * this output to turn on an external amplifier.
13195          */
13196         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
13197         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
13198
13199         { } /* end */
13200 };
13201 #endif
13202
13203 /* create input playback/capture controls for the given pin */
13204 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
13205                                     const char *ctlname, int idx)
13206 {
13207         hda_nid_t dac;
13208         int err;
13209
13210         switch (nid) {
13211         case 0x14:
13212         case 0x16:
13213                 dac = 0x02;
13214                 break;
13215         case 0x15:
13216         case 0x1a: /* ALC259/269 only */
13217         case 0x1b: /* ALC259/269 only */
13218         case 0x21: /* ALC269vb has this pin, too */
13219                 dac = 0x03;
13220                 break;
13221         default:
13222                 snd_printd(KERN_WARNING "hda_codec: "
13223                            "ignoring pin 0x%x as unknown\n", nid);
13224                 return 0;
13225         }
13226         if (spec->multiout.dac_nids[0] != dac &&
13227             spec->multiout.dac_nids[1] != dac) {
13228                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
13229                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
13230                                                       HDA_OUTPUT));
13231                 if (err < 0)
13232                         return err;
13233                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
13234         }
13235
13236         if (nid != 0x16)
13237                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13238                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
13239         else /* mono */
13240                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
13241                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
13242         if (err < 0)
13243                 return err;
13244         return 0;
13245 }
13246
13247 /* add playback controls from the parsed DAC table */
13248 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
13249                                              const struct auto_pin_cfg *cfg)
13250 {
13251         hda_nid_t nid;
13252         int err;
13253
13254         spec->multiout.dac_nids = spec->private_dac_nids;
13255
13256         nid = cfg->line_out_pins[0];
13257         if (nid) {
13258                 const char *name;
13259                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
13260                         name = "Speaker";
13261                 else
13262                         name = "Front";
13263                 err = alc268_new_analog_output(spec, nid, name, 0);
13264                 if (err < 0)
13265                         return err;
13266         }
13267
13268         nid = cfg->speaker_pins[0];
13269         if (nid == 0x1d) {
13270                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
13271                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
13272                 if (err < 0)
13273                         return err;
13274         } else if (nid) {
13275                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
13276                 if (err < 0)
13277                         return err;
13278         }
13279         nid = cfg->hp_pins[0];
13280         if (nid) {
13281                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
13282                 if (err < 0)
13283                         return err;
13284         }
13285
13286         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
13287         if (nid == 0x16) {
13288                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
13289                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
13290                 if (err < 0)
13291                         return err;
13292         }
13293         return 0;
13294 }
13295
13296 /* create playback/capture controls for input pins */
13297 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
13298                                                 const struct auto_pin_cfg *cfg)
13299 {
13300         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
13301 }
13302
13303 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
13304                                               hda_nid_t nid, int pin_type)
13305 {
13306         int idx;
13307
13308         alc_set_pin_output(codec, nid, pin_type);
13309         if (nid == 0x14 || nid == 0x16)
13310                 idx = 0;
13311         else
13312                 idx = 1;
13313         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
13314 }
13315
13316 static void alc268_auto_init_multi_out(struct hda_codec *codec)
13317 {
13318         struct alc_spec *spec = codec->spec;
13319         hda_nid_t nid = spec->autocfg.line_out_pins[0];
13320         if (nid) {
13321                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
13322                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
13323         }
13324 }
13325
13326 static void alc268_auto_init_hp_out(struct hda_codec *codec)
13327 {
13328         struct alc_spec *spec = codec->spec;
13329         hda_nid_t pin;
13330
13331         pin = spec->autocfg.hp_pins[0];
13332         if (pin)
13333                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
13334         pin = spec->autocfg.speaker_pins[0];
13335         if (pin)
13336                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
13337 }
13338
13339 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
13340 {
13341         struct alc_spec *spec = codec->spec;
13342         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
13343         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
13344         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
13345         unsigned int    dac_vol1, dac_vol2;
13346
13347         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13348                 snd_hda_codec_write(codec, speaker_nid, 0,
13349                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13350                 /* mute mixer inputs from 0x1d */
13351                 snd_hda_codec_write(codec, 0x0f, 0,
13352                                     AC_VERB_SET_AMP_GAIN_MUTE,
13353                                     AMP_IN_UNMUTE(1));
13354                 snd_hda_codec_write(codec, 0x10, 0,
13355                                     AC_VERB_SET_AMP_GAIN_MUTE,
13356                                     AMP_IN_UNMUTE(1));
13357         } else {
13358                 /* unmute mixer inputs from 0x1d */
13359                 snd_hda_codec_write(codec, 0x0f, 0,
13360                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13361                 snd_hda_codec_write(codec, 0x10, 0,
13362                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13363         }
13364
13365         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13366         if (line_nid == 0x14)
13367                 dac_vol2 = AMP_OUT_ZERO;
13368         else if (line_nid == 0x15)
13369                 dac_vol1 = AMP_OUT_ZERO;
13370         if (hp_nid == 0x14)
13371                 dac_vol2 = AMP_OUT_ZERO;
13372         else if (hp_nid == 0x15)
13373                 dac_vol1 = AMP_OUT_ZERO;
13374         if (line_nid != 0x16 || hp_nid != 0x16 ||
13375             spec->autocfg.line_out_pins[1] != 0x16 ||
13376             spec->autocfg.line_out_pins[2] != 0x16)
13377                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13378
13379         snd_hda_codec_write(codec, 0x02, 0,
13380                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13381         snd_hda_codec_write(codec, 0x03, 0,
13382                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13383 }
13384
13385 /* pcm configuration: identical with ALC880 */
13386 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13387 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13388 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13389 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13390
13391 /*
13392  * BIOS auto configuration
13393  */
13394 static int alc268_parse_auto_config(struct hda_codec *codec)
13395 {
13396         struct alc_spec *spec = codec->spec;
13397         int err;
13398         static hda_nid_t alc268_ignore[] = { 0 };
13399
13400         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13401                                            alc268_ignore);
13402         if (err < 0)
13403                 return err;
13404         if (!spec->autocfg.line_outs) {
13405                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13406                         spec->multiout.max_channels = 2;
13407                         spec->no_analog = 1;
13408                         goto dig_only;
13409                 }
13410                 return 0; /* can't find valid BIOS pin config */
13411         }
13412         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13413         if (err < 0)
13414                 return err;
13415         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13416         if (err < 0)
13417                 return err;
13418
13419         spec->multiout.max_channels = 2;
13420
13421  dig_only:
13422         /* digital only support output */
13423         alc_auto_parse_digital(codec);
13424         if (spec->kctls.list)
13425                 add_mixer(spec, spec->kctls.list);
13426
13427         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13428                 add_mixer(spec, alc268_beep_mixer);
13429
13430         add_verb(spec, alc268_volume_init_verbs);
13431         spec->num_mux_defs = 2;
13432         spec->input_mux = &spec->private_imux[0];
13433
13434         err = alc_auto_add_mic_boost(codec);
13435         if (err < 0)
13436                 return err;
13437
13438         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13439
13440         return 1;
13441 }
13442
13443 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13444
13445 /* init callback for auto-configuration model -- overriding the default init */
13446 static void alc268_auto_init(struct hda_codec *codec)
13447 {
13448         struct alc_spec *spec = codec->spec;
13449         alc268_auto_init_multi_out(codec);
13450         alc268_auto_init_hp_out(codec);
13451         alc268_auto_init_mono_speaker_out(codec);
13452         alc268_auto_init_analog_input(codec);
13453         alc_auto_init_digital(codec);
13454         if (spec->unsol_event)
13455                 alc_inithook(codec);
13456 }
13457
13458 /*
13459  * configuration and preset
13460  */
13461 static const char *alc268_models[ALC268_MODEL_LAST] = {
13462         [ALC267_QUANTA_IL1]     = "quanta-il1",
13463         [ALC268_3ST]            = "3stack",
13464         [ALC268_TOSHIBA]        = "toshiba",
13465         [ALC268_ACER]           = "acer",
13466         [ALC268_ACER_DMIC]      = "acer-dmic",
13467         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13468         [ALC268_DELL]           = "dell",
13469         [ALC268_ZEPTO]          = "zepto",
13470 #ifdef CONFIG_SND_DEBUG
13471         [ALC268_TEST]           = "test",
13472 #endif
13473         [ALC268_AUTO]           = "auto",
13474 };
13475
13476 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13477         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13478         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13479         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13480         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13481         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13482         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13483                                                 ALC268_ACER_ASPIRE_ONE),
13484         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13485         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13486                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13487         /* almost compatible with toshiba but with optional digital outs;
13488          * auto-probing seems working fine
13489          */
13490         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13491                            ALC268_AUTO),
13492         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13493         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13494         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13495         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13496         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13497         {}
13498 };
13499
13500 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13501 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13502         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13503         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13504         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13505                            ALC268_TOSHIBA),
13506         {}
13507 };
13508
13509 static struct alc_config_preset alc268_presets[] = {
13510         [ALC267_QUANTA_IL1] = {
13511                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13512                             alc268_capture_nosrc_mixer },
13513                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13514                                 alc267_quanta_il1_verbs },
13515                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13516                 .dac_nids = alc268_dac_nids,
13517                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13518                 .adc_nids = alc268_adc_nids_alt,
13519                 .hp_nid = 0x03,
13520                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13521                 .channel_mode = alc268_modes,
13522                 .unsol_event = alc_sku_unsol_event,
13523                 .setup = alc267_quanta_il1_setup,
13524                 .init_hook = alc_inithook,
13525         },
13526         [ALC268_3ST] = {
13527                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13528                             alc268_beep_mixer },
13529                 .init_verbs = { alc268_base_init_verbs },
13530                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13531                 .dac_nids = alc268_dac_nids,
13532                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13533                 .adc_nids = alc268_adc_nids_alt,
13534                 .capsrc_nids = alc268_capsrc_nids,
13535                 .hp_nid = 0x03,
13536                 .dig_out_nid = ALC268_DIGOUT_NID,
13537                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13538                 .channel_mode = alc268_modes,
13539                 .input_mux = &alc268_capture_source,
13540         },
13541         [ALC268_TOSHIBA] = {
13542                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13543                             alc268_beep_mixer },
13544                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13545                                 alc268_toshiba_verbs },
13546                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13547                 .dac_nids = alc268_dac_nids,
13548                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13549                 .adc_nids = alc268_adc_nids_alt,
13550                 .capsrc_nids = alc268_capsrc_nids,
13551                 .hp_nid = 0x03,
13552                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13553                 .channel_mode = alc268_modes,
13554                 .input_mux = &alc268_capture_source,
13555                 .unsol_event = alc268_toshiba_unsol_event,
13556                 .setup = alc268_toshiba_setup,
13557                 .init_hook = alc268_toshiba_automute,
13558         },
13559         [ALC268_ACER] = {
13560                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13561                             alc268_beep_mixer },
13562                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13563                                 alc268_acer_verbs },
13564                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13565                 .dac_nids = alc268_dac_nids,
13566                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13567                 .adc_nids = alc268_adc_nids_alt,
13568                 .capsrc_nids = alc268_capsrc_nids,
13569                 .hp_nid = 0x02,
13570                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13571                 .channel_mode = alc268_modes,
13572                 .input_mux = &alc268_acer_capture_source,
13573                 .unsol_event = alc268_acer_unsol_event,
13574                 .init_hook = alc268_acer_init_hook,
13575         },
13576         [ALC268_ACER_DMIC] = {
13577                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13578                             alc268_beep_mixer },
13579                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13580                                 alc268_acer_verbs },
13581                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13582                 .dac_nids = alc268_dac_nids,
13583                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13584                 .adc_nids = alc268_adc_nids_alt,
13585                 .capsrc_nids = alc268_capsrc_nids,
13586                 .hp_nid = 0x02,
13587                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13588                 .channel_mode = alc268_modes,
13589                 .input_mux = &alc268_acer_dmic_capture_source,
13590                 .unsol_event = alc268_acer_unsol_event,
13591                 .init_hook = alc268_acer_init_hook,
13592         },
13593         [ALC268_ACER_ASPIRE_ONE] = {
13594                 .mixers = { alc268_acer_aspire_one_mixer,
13595                             alc268_beep_mixer,
13596                             alc268_capture_nosrc_mixer },
13597                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13598                                 alc268_acer_aspire_one_verbs },
13599                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13600                 .dac_nids = alc268_dac_nids,
13601                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13602                 .adc_nids = alc268_adc_nids_alt,
13603                 .capsrc_nids = alc268_capsrc_nids,
13604                 .hp_nid = 0x03,
13605                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13606                 .channel_mode = alc268_modes,
13607                 .unsol_event = alc268_acer_lc_unsol_event,
13608                 .setup = alc268_acer_lc_setup,
13609                 .init_hook = alc268_acer_lc_init_hook,
13610         },
13611         [ALC268_DELL] = {
13612                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13613                             alc268_capture_nosrc_mixer },
13614                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13615                                 alc268_dell_verbs },
13616                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13617                 .dac_nids = alc268_dac_nids,
13618                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13619                 .adc_nids = alc268_adc_nids_alt,
13620                 .capsrc_nids = alc268_capsrc_nids,
13621                 .hp_nid = 0x02,
13622                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13623                 .channel_mode = alc268_modes,
13624                 .unsol_event = alc_sku_unsol_event,
13625                 .setup = alc268_dell_setup,
13626                 .init_hook = alc_inithook,
13627         },
13628         [ALC268_ZEPTO] = {
13629                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13630                             alc268_beep_mixer },
13631                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13632                                 alc268_toshiba_verbs },
13633                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13634                 .dac_nids = alc268_dac_nids,
13635                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13636                 .adc_nids = alc268_adc_nids_alt,
13637                 .capsrc_nids = alc268_capsrc_nids,
13638                 .hp_nid = 0x03,
13639                 .dig_out_nid = ALC268_DIGOUT_NID,
13640                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13641                 .channel_mode = alc268_modes,
13642                 .input_mux = &alc268_capture_source,
13643                 .setup = alc268_toshiba_setup,
13644                 .init_hook = alc268_toshiba_automute,
13645         },
13646 #ifdef CONFIG_SND_DEBUG
13647         [ALC268_TEST] = {
13648                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13649                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13650                                 alc268_volume_init_verbs },
13651                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13652                 .dac_nids = alc268_dac_nids,
13653                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13654                 .adc_nids = alc268_adc_nids_alt,
13655                 .capsrc_nids = alc268_capsrc_nids,
13656                 .hp_nid = 0x03,
13657                 .dig_out_nid = ALC268_DIGOUT_NID,
13658                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13659                 .channel_mode = alc268_modes,
13660                 .input_mux = &alc268_capture_source,
13661         },
13662 #endif
13663 };
13664
13665 static int patch_alc268(struct hda_codec *codec)
13666 {
13667         struct alc_spec *spec;
13668         int board_config;
13669         int i, has_beep, err;
13670
13671         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13672         if (spec == NULL)
13673                 return -ENOMEM;
13674
13675         codec->spec = spec;
13676
13677         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13678                                                   alc268_models,
13679                                                   alc268_cfg_tbl);
13680
13681         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13682                 board_config = snd_hda_check_board_codec_sid_config(codec,
13683                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13684
13685         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13686                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13687                        codec->chip_name);
13688                 board_config = ALC268_AUTO;
13689         }
13690
13691         if (board_config == ALC268_AUTO) {
13692                 /* automatic parse from the BIOS config */
13693                 err = alc268_parse_auto_config(codec);
13694                 if (err < 0) {
13695                         alc_free(codec);
13696                         return err;
13697                 } else if (!err) {
13698                         printk(KERN_INFO
13699                                "hda_codec: Cannot set up configuration "
13700                                "from BIOS.  Using base mode...\n");
13701                         board_config = ALC268_3ST;
13702                 }
13703         }
13704
13705         if (board_config != ALC268_AUTO)
13706                 setup_preset(codec, &alc268_presets[board_config]);
13707
13708         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13709         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13710         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13711
13712         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13713
13714         has_beep = 0;
13715         for (i = 0; i < spec->num_mixers; i++) {
13716                 if (spec->mixers[i] == alc268_beep_mixer) {
13717                         has_beep = 1;
13718                         break;
13719                 }
13720         }
13721
13722         if (has_beep) {
13723                 err = snd_hda_attach_beep_device(codec, 0x1);
13724                 if (err < 0) {
13725                         alc_free(codec);
13726                         return err;
13727                 }
13728                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13729                         /* override the amp caps for beep generator */
13730                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13731                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13732                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13733                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13734                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13735         }
13736
13737         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13738                 /* check whether NID 0x07 is valid */
13739                 unsigned int wcap = get_wcaps(codec, 0x07);
13740                 int i;
13741
13742                 spec->capsrc_nids = alc268_capsrc_nids;
13743                 /* get type */
13744                 wcap = get_wcaps_type(wcap);
13745                 if (spec->auto_mic ||
13746                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13747                         spec->adc_nids = alc268_adc_nids_alt;
13748                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13749                         if (spec->auto_mic)
13750                                 fixup_automic_adc(codec);
13751                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13752                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13753                         else
13754                                 add_mixer(spec, alc268_capture_alt_mixer);
13755                 } else {
13756                         spec->adc_nids = alc268_adc_nids;
13757                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13758                         add_mixer(spec, alc268_capture_mixer);
13759                 }
13760                 /* set default input source */
13761                 for (i = 0; i < spec->num_adc_nids; i++)
13762                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13763                                 0, AC_VERB_SET_CONNECT_SEL,
13764                                 i < spec->num_mux_defs ?
13765                                 spec->input_mux[i].items[0].index :
13766                                 spec->input_mux->items[0].index);
13767         }
13768
13769         spec->vmaster_nid = 0x02;
13770
13771         codec->patch_ops = alc_patch_ops;
13772         if (board_config == ALC268_AUTO)
13773                 spec->init_hook = alc268_auto_init;
13774
13775         return 0;
13776 }
13777
13778 /*
13779  *  ALC269 channel source setting (2 channel)
13780  */
13781 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13782
13783 #define alc269_dac_nids         alc260_dac_nids
13784
13785 static hda_nid_t alc269_adc_nids[1] = {
13786         /* ADC1 */
13787         0x08,
13788 };
13789
13790 static hda_nid_t alc269_capsrc_nids[1] = {
13791         0x23,
13792 };
13793
13794 static hda_nid_t alc269vb_adc_nids[1] = {
13795         /* ADC1 */
13796         0x09,
13797 };
13798
13799 static hda_nid_t alc269vb_capsrc_nids[1] = {
13800         0x22,
13801 };
13802
13803 static hda_nid_t alc269_adc_candidates[] = {
13804         0x08, 0x09, 0x07,
13805 };
13806
13807 #define alc269_modes            alc260_modes
13808 #define alc269_capture_source   alc880_lg_lw_capture_source
13809
13810 static struct snd_kcontrol_new alc269_base_mixer[] = {
13811         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13812         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13813         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13814         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13815         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13816         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13817         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13818         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13819         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13820         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13821         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13822         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13823         { } /* end */
13824 };
13825
13826 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13827         /* output mixer control */
13828         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13829         {
13830                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13831                 .name = "Master Playback Switch",
13832                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13833                 .info = snd_hda_mixer_amp_switch_info,
13834                 .get = snd_hda_mixer_amp_switch_get,
13835                 .put = alc268_acer_master_sw_put,
13836                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13837         },
13838         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13839         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13840         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13841         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13842         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13843         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13844         { }
13845 };
13846
13847 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13848         /* output mixer control */
13849         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13850         {
13851                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13852                 .name = "Master Playback Switch",
13853                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13854                 .info = snd_hda_mixer_amp_switch_info,
13855                 .get = snd_hda_mixer_amp_switch_get,
13856                 .put = alc268_acer_master_sw_put,
13857                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13858         },
13859         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13860         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13861         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13862         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13863         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13864         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13865         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13866         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13867         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13868         { }
13869 };
13870
13871 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
13872         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13873         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13874         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13875         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13876         { } /* end */
13877 };
13878
13879 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
13880         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13881         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13882         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13883         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13884         { } /* end */
13885 };
13886
13887 static struct snd_kcontrol_new alc269_asus_mixer[] = {
13888         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13889         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x0, HDA_INPUT),
13890         { } /* end */
13891 };
13892
13893 /* capture mixer elements */
13894 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
13895         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13896         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13897         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13898         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13899         { } /* end */
13900 };
13901
13902 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
13903         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13904         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13905         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13906         { } /* end */
13907 };
13908
13909 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
13910         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13911         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13912         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13913         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13914         { } /* end */
13915 };
13916
13917 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
13918         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13919         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13920         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13921         { } /* end */
13922 };
13923
13924 /* FSC amilo */
13925 #define alc269_fujitsu_mixer    alc269_laptop_mixer
13926
13927 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13928         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13929         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13930         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13931         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13932         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13933         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13934         { }
13935 };
13936
13937 static struct hda_verb alc269_lifebook_verbs[] = {
13938         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13939         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13940         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13941         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13942         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13943         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13944         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13945         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13946         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13947         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13948         { }
13949 };
13950
13951 /* toggle speaker-output according to the hp-jack state */
13952 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13953 {
13954         unsigned int present;
13955         unsigned char bits;
13956
13957         present = snd_hda_jack_detect(codec, 0x15);
13958         bits = present ? HDA_AMP_MUTE : 0;
13959         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13960                                  HDA_AMP_MUTE, bits);
13961         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13962                                  HDA_AMP_MUTE, bits);
13963
13964         snd_hda_codec_write(codec, 0x20, 0,
13965                         AC_VERB_SET_COEF_INDEX, 0x0c);
13966         snd_hda_codec_write(codec, 0x20, 0,
13967                         AC_VERB_SET_PROC_COEF, 0x680);
13968
13969         snd_hda_codec_write(codec, 0x20, 0,
13970                         AC_VERB_SET_COEF_INDEX, 0x0c);
13971         snd_hda_codec_write(codec, 0x20, 0,
13972                         AC_VERB_SET_PROC_COEF, 0x480);
13973 }
13974
13975 /* toggle speaker-output according to the hp-jacks state */
13976 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13977 {
13978         unsigned int present;
13979         unsigned char bits;
13980
13981         /* Check laptop headphone socket */
13982         present = snd_hda_jack_detect(codec, 0x15);
13983
13984         /* Check port replicator headphone socket */
13985         present |= snd_hda_jack_detect(codec, 0x1a);
13986
13987         bits = present ? HDA_AMP_MUTE : 0;
13988         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13989                                  HDA_AMP_MUTE, bits);
13990         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13991                                  HDA_AMP_MUTE, bits);
13992
13993         snd_hda_codec_write(codec, 0x20, 0,
13994                         AC_VERB_SET_COEF_INDEX, 0x0c);
13995         snd_hda_codec_write(codec, 0x20, 0,
13996                         AC_VERB_SET_PROC_COEF, 0x680);
13997
13998         snd_hda_codec_write(codec, 0x20, 0,
13999                         AC_VERB_SET_COEF_INDEX, 0x0c);
14000         snd_hda_codec_write(codec, 0x20, 0,
14001                         AC_VERB_SET_PROC_COEF, 0x480);
14002 }
14003
14004 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
14005 {
14006         unsigned int present_laptop;
14007         unsigned int present_dock;
14008
14009         present_laptop  = snd_hda_jack_detect(codec, 0x18);
14010         present_dock    = snd_hda_jack_detect(codec, 0x1b);
14011
14012         /* Laptop mic port overrides dock mic port, design decision */
14013         if (present_dock)
14014                 snd_hda_codec_write(codec, 0x23, 0,
14015                                 AC_VERB_SET_CONNECT_SEL, 0x3);
14016         if (present_laptop)
14017                 snd_hda_codec_write(codec, 0x23, 0,
14018                                 AC_VERB_SET_CONNECT_SEL, 0x0);
14019         if (!present_dock && !present_laptop)
14020                 snd_hda_codec_write(codec, 0x23, 0,
14021                                 AC_VERB_SET_CONNECT_SEL, 0x1);
14022 }
14023
14024 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
14025                                     unsigned int res)
14026 {
14027         switch (res >> 26) {
14028         case ALC880_HP_EVENT:
14029                 alc269_quanta_fl1_speaker_automute(codec);
14030                 break;
14031         case ALC880_MIC_EVENT:
14032                 alc_mic_automute(codec);
14033                 break;
14034         }
14035 }
14036
14037 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
14038                                         unsigned int res)
14039 {
14040         if ((res >> 26) == ALC880_HP_EVENT)
14041                 alc269_lifebook_speaker_automute(codec);
14042         if ((res >> 26) == ALC880_MIC_EVENT)
14043                 alc269_lifebook_mic_autoswitch(codec);
14044 }
14045
14046 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
14047 {
14048         struct alc_spec *spec = codec->spec;
14049         spec->autocfg.hp_pins[0] = 0x15;
14050         spec->autocfg.speaker_pins[0] = 0x14;
14051         spec->ext_mic.pin = 0x18;
14052         spec->ext_mic.mux_idx = 0;
14053         spec->int_mic.pin = 0x19;
14054         spec->int_mic.mux_idx = 1;
14055         spec->auto_mic = 1;
14056 }
14057
14058 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
14059 {
14060         alc269_quanta_fl1_speaker_automute(codec);
14061         alc_mic_automute(codec);
14062 }
14063
14064 static void alc269_lifebook_init_hook(struct hda_codec *codec)
14065 {
14066         alc269_lifebook_speaker_automute(codec);
14067         alc269_lifebook_mic_autoswitch(codec);
14068 }
14069
14070 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
14071         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14072         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
14073         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14074         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14075         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14076         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14077         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14078         {}
14079 };
14080
14081 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
14082         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
14083         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
14084         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14085         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
14086         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14087         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14088         {}
14089 };
14090
14091 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
14092         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14093         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
14094         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14095         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14096         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14097         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14098         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14099         {}
14100 };
14101
14102 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
14103         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
14104         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
14105         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
14106         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
14107         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14108         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14109         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14110         {}
14111 };
14112
14113 static struct hda_verb alc271_acer_dmic_verbs[] = {
14114         {0x20, AC_VERB_SET_COEF_INDEX, 0x0d},
14115         {0x20, AC_VERB_SET_PROC_COEF, 0x4000},
14116         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14117         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14118         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14119         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14120         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},
14121         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14122         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
14123         {0x22, AC_VERB_SET_CONNECT_SEL, 6},
14124         { }
14125 };
14126
14127 /* toggle speaker-output according to the hp-jack state */
14128 static void alc269_speaker_automute(struct hda_codec *codec)
14129 {
14130         struct alc_spec *spec = codec->spec;
14131         unsigned int nid = spec->autocfg.hp_pins[0];
14132         unsigned int present;
14133         unsigned char bits;
14134
14135         present = snd_hda_jack_detect(codec, nid);
14136         bits = present ? HDA_AMP_MUTE : 0;
14137         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
14138                                  HDA_AMP_MUTE, bits);
14139         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
14140                                  HDA_AMP_MUTE, bits);
14141 }
14142
14143 /* unsolicited event for HP jack sensing */
14144 static void alc269_laptop_unsol_event(struct hda_codec *codec,
14145                                      unsigned int res)
14146 {
14147         switch (res >> 26) {
14148         case ALC880_HP_EVENT:
14149                 alc269_speaker_automute(codec);
14150                 break;
14151         case ALC880_MIC_EVENT:
14152                 alc_mic_automute(codec);
14153                 break;
14154         }
14155 }
14156
14157 static void alc269_laptop_amic_setup(struct hda_codec *codec)
14158 {
14159         struct alc_spec *spec = codec->spec;
14160         spec->autocfg.hp_pins[0] = 0x15;
14161         spec->autocfg.speaker_pins[0] = 0x14;
14162         spec->ext_mic.pin = 0x18;
14163         spec->ext_mic.mux_idx = 0;
14164         spec->int_mic.pin = 0x19;
14165         spec->int_mic.mux_idx = 1;
14166         spec->auto_mic = 1;
14167 }
14168
14169 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
14170 {
14171         struct alc_spec *spec = codec->spec;
14172         spec->autocfg.hp_pins[0] = 0x15;
14173         spec->autocfg.speaker_pins[0] = 0x14;
14174         spec->ext_mic.pin = 0x18;
14175         spec->ext_mic.mux_idx = 0;
14176         spec->int_mic.pin = 0x12;
14177         spec->int_mic.mux_idx = 5;
14178         spec->auto_mic = 1;
14179 }
14180
14181 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
14182 {
14183         struct alc_spec *spec = codec->spec;
14184         spec->autocfg.hp_pins[0] = 0x21;
14185         spec->autocfg.speaker_pins[0] = 0x14;
14186         spec->ext_mic.pin = 0x18;
14187         spec->ext_mic.mux_idx = 0;
14188         spec->int_mic.pin = 0x19;
14189         spec->int_mic.mux_idx = 1;
14190         spec->auto_mic = 1;
14191 }
14192
14193 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
14194 {
14195         struct alc_spec *spec = codec->spec;
14196         spec->autocfg.hp_pins[0] = 0x21;
14197         spec->autocfg.speaker_pins[0] = 0x14;
14198         spec->ext_mic.pin = 0x18;
14199         spec->ext_mic.mux_idx = 0;
14200         spec->int_mic.pin = 0x12;
14201         spec->int_mic.mux_idx = 6;
14202         spec->auto_mic = 1;
14203 }
14204
14205 static void alc269_laptop_inithook(struct hda_codec *codec)
14206 {
14207         alc269_speaker_automute(codec);
14208         alc_mic_automute(codec);
14209 }
14210
14211 /*
14212  * generic initialization of ADC, input mixers and output mixers
14213  */
14214 static struct hda_verb alc269_init_verbs[] = {
14215         /*
14216          * Unmute ADC0 and set the default input to mic-in
14217          */
14218         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14219
14220         /*
14221          * Set up output mixers (0x02 - 0x03)
14222          */
14223         /* set vol=0 to output mixers */
14224         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14225         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14226
14227         /* set up input amps for analog loopback */
14228         /* Amp Indices: DAC = 0, mixer = 1 */
14229         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14230         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14231         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14232         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14233         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14234         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14235
14236         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14237         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14238         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14239         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14240         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14241         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14242         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14243
14244         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14245         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14246
14247         /* FIXME: use Mux-type input source selection */
14248         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14249         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14250         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
14251
14252         /* set EAPD */
14253         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14254         { }
14255 };
14256
14257 static struct hda_verb alc269vb_init_verbs[] = {
14258         /*
14259          * Unmute ADC0 and set the default input to mic-in
14260          */
14261         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14262
14263         /*
14264          * Set up output mixers (0x02 - 0x03)
14265          */
14266         /* set vol=0 to output mixers */
14267         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14268         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14269
14270         /* set up input amps for analog loopback */
14271         /* Amp Indices: DAC = 0, mixer = 1 */
14272         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14273         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14274         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14275         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14276         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14277         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14278
14279         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14280         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14281         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14282         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14283         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14284         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14285         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14286
14287         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14288         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14289
14290         /* FIXME: use Mux-type input source selection */
14291         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
14292         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
14293         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
14294
14295         /* set EAPD */
14296         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
14297         { }
14298 };
14299
14300 #define alc269_auto_create_multi_out_ctls \
14301         alc268_auto_create_multi_out_ctls
14302 #define alc269_auto_create_input_ctls \
14303         alc268_auto_create_input_ctls
14304
14305 #ifdef CONFIG_SND_HDA_POWER_SAVE
14306 #define alc269_loopbacks        alc880_loopbacks
14307 #endif
14308
14309 /* pcm configuration: identical with ALC880 */
14310 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
14311 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
14312 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
14313 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
14314
14315 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
14316         .substreams = 1,
14317         .channels_min = 2,
14318         .channels_max = 8,
14319         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14320         /* NID is set in alc_build_pcms */
14321         .ops = {
14322                 .open = alc880_playback_pcm_open,
14323                 .prepare = alc880_playback_pcm_prepare,
14324                 .cleanup = alc880_playback_pcm_cleanup
14325         },
14326 };
14327
14328 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
14329         .substreams = 1,
14330         .channels_min = 2,
14331         .channels_max = 2,
14332         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
14333         /* NID is set in alc_build_pcms */
14334 };
14335
14336 #ifdef CONFIG_SND_HDA_POWER_SAVE
14337 static int alc269_mic2_for_mute_led(struct hda_codec *codec)
14338 {
14339         switch (codec->subsystem_id) {
14340         case 0x103c1586:
14341                 return 1;
14342         }
14343         return 0;
14344 }
14345
14346 static int alc269_mic2_mute_check_ps(struct hda_codec *codec, hda_nid_t nid)
14347 {
14348         /* update mute-LED according to the speaker mute state */
14349         if (nid == 0x01 || nid == 0x14) {
14350                 int pinval;
14351                 if (snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0) &
14352                     HDA_AMP_MUTE)
14353                         pinval = 0x24;
14354                 else
14355                         pinval = 0x20;
14356                 /* mic2 vref pin is used for mute LED control */
14357                 snd_hda_codec_update_cache(codec, 0x19, 0,
14358                                            AC_VERB_SET_PIN_WIDGET_CONTROL,
14359                                            pinval);
14360         }
14361         return alc_check_power_status(codec, nid);
14362 }
14363 #endif /* CONFIG_SND_HDA_POWER_SAVE */
14364
14365 static int alc275_setup_dual_adc(struct hda_codec *codec)
14366 {
14367         struct alc_spec *spec = codec->spec;
14368
14369         if (codec->vendor_id != 0x10ec0275 || !spec->auto_mic)
14370                 return 0;
14371         if ((spec->ext_mic.pin >= 0x18 && spec->int_mic.pin <= 0x13) ||
14372             (spec->ext_mic.pin <= 0x12 && spec->int_mic.pin >= 0x18)) {
14373                 if (spec->ext_mic.pin <= 0x12) {
14374                         spec->private_adc_nids[0] = 0x08;
14375                         spec->private_adc_nids[1] = 0x11;
14376                         spec->private_capsrc_nids[0] = 0x23;
14377                         spec->private_capsrc_nids[1] = 0x22;
14378                 } else {
14379                         spec->private_adc_nids[0] = 0x11;
14380                         spec->private_adc_nids[1] = 0x08;
14381                         spec->private_capsrc_nids[0] = 0x22;
14382                         spec->private_capsrc_nids[1] = 0x23;
14383                 }
14384                 spec->adc_nids = spec->private_adc_nids;
14385                 spec->capsrc_nids = spec->private_capsrc_nids;
14386                 spec->num_adc_nids = 2;
14387                 spec->dual_adc_switch = 1;
14388                 snd_printdd("realtek: enabling dual ADC switchg (%02x:%02x)\n",
14389                             spec->adc_nids[0], spec->adc_nids[1]);
14390                 return 1;
14391         }
14392         return 0;
14393 }
14394
14395 /*
14396  * BIOS auto configuration
14397  */
14398 static int alc269_parse_auto_config(struct hda_codec *codec)
14399 {
14400         struct alc_spec *spec = codec->spec;
14401         int err;
14402         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
14403
14404         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14405                                            alc269_ignore);
14406         if (err < 0)
14407                 return err;
14408
14409         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
14410         if (err < 0)
14411                 return err;
14412         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
14413         if (err < 0)
14414                 return err;
14415
14416         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14417
14418         alc_auto_parse_digital(codec);
14419
14420         if (spec->kctls.list)
14421                 add_mixer(spec, spec->kctls.list);
14422
14423         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
14424                 add_verb(spec, alc269vb_init_verbs);
14425                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14426         } else {
14427                 add_verb(spec, alc269_init_verbs);
14428                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14429         }
14430
14431         spec->num_mux_defs = 1;
14432         spec->input_mux = &spec->private_imux[0];
14433
14434         if (!alc275_setup_dual_adc(codec))
14435                 fillup_priv_adc_nids(codec, alc269_adc_candidates,
14436                                      sizeof(alc269_adc_candidates));
14437
14438         /* set default input source */
14439         if (!spec->dual_adc_switch)
14440                 select_or_unmute_capsrc(codec, spec->capsrc_nids[0],
14441                                         spec->input_mux->items[0].index);
14442
14443         err = alc_auto_add_mic_boost(codec);
14444         if (err < 0)
14445                 return err;
14446
14447         if (!spec->cap_mixer && !spec->no_analog)
14448                 set_capture_mixer(codec);
14449
14450         return 1;
14451 }
14452
14453 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14454 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14455 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14456
14457
14458 /* init callback for auto-configuration model -- overriding the default init */
14459 static void alc269_auto_init(struct hda_codec *codec)
14460 {
14461         struct alc_spec *spec = codec->spec;
14462         alc269_auto_init_multi_out(codec);
14463         alc269_auto_init_hp_out(codec);
14464         alc269_auto_init_analog_input(codec);
14465         alc_auto_init_digital(codec);
14466         if (spec->unsol_event)
14467                 alc_inithook(codec);
14468 }
14469
14470 enum {
14471         ALC269_FIXUP_SONY_VAIO,
14472 };
14473
14474 static const struct alc_fixup alc269_fixups[] = {
14475         [ALC269_FIXUP_SONY_VAIO] = {
14476                 .verbs = (const struct hda_verb[]) {
14477                         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREFGRD},
14478                         {}
14479                 }
14480         },
14481 };
14482
14483 static struct snd_pci_quirk alc269_fixup_tbl[] = {
14484         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14485         SND_PCI_QUIRK(0x104d, 0x9077, "Sony VAIO", ALC269_FIXUP_SONY_VAIO),
14486         {}
14487 };
14488
14489
14490 /*
14491  * configuration and preset
14492  */
14493 static const char *alc269_models[ALC269_MODEL_LAST] = {
14494         [ALC269_BASIC]                  = "basic",
14495         [ALC269_QUANTA_FL1]             = "quanta",
14496         [ALC269_AMIC]                   = "laptop-amic",
14497         [ALC269_DMIC]                   = "laptop-dmic",
14498         [ALC269_FUJITSU]                = "fujitsu",
14499         [ALC269_LIFEBOOK]               = "lifebook",
14500         [ALC269_AUTO]                   = "auto",
14501 };
14502
14503 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14504         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14505         SND_PCI_QUIRK(0x1025, 0x047c, "ACER ZGA", ALC271_ACER),
14506         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14507                       ALC269_AMIC),
14508         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14509         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14510         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14511         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14512         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14513         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14514         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14515         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14516         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14517         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14518         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14519         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14520         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14521         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14522         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14523         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14524         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14525         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14526         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14527         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14528         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14529         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14530         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14531         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14532         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14533         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14534         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14535         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14536         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14537         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14538         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14539         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14540         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14541         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14542         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14543         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14544         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14545                       ALC269_DMIC),
14546         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14547                       ALC269_DMIC),
14548         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14549         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14550         SND_PCI_QUIRK(0x104d, 0x9071, "Sony VAIO", ALC269_AUTO),
14551         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14552         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14553         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14554         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14555         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14556         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14557         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14558         {}
14559 };
14560
14561 static struct alc_config_preset alc269_presets[] = {
14562         [ALC269_BASIC] = {
14563                 .mixers = { alc269_base_mixer },
14564                 .init_verbs = { alc269_init_verbs },
14565                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14566                 .dac_nids = alc269_dac_nids,
14567                 .hp_nid = 0x03,
14568                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14569                 .channel_mode = alc269_modes,
14570                 .input_mux = &alc269_capture_source,
14571         },
14572         [ALC269_QUANTA_FL1] = {
14573                 .mixers = { alc269_quanta_fl1_mixer },
14574                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14575                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14576                 .dac_nids = alc269_dac_nids,
14577                 .hp_nid = 0x03,
14578                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14579                 .channel_mode = alc269_modes,
14580                 .input_mux = &alc269_capture_source,
14581                 .unsol_event = alc269_quanta_fl1_unsol_event,
14582                 .setup = alc269_quanta_fl1_setup,
14583                 .init_hook = alc269_quanta_fl1_init_hook,
14584         },
14585         [ALC269_AMIC] = {
14586                 .mixers = { alc269_laptop_mixer },
14587                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14588                 .init_verbs = { alc269_init_verbs,
14589                                 alc269_laptop_amic_init_verbs },
14590                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14591                 .dac_nids = alc269_dac_nids,
14592                 .hp_nid = 0x03,
14593                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14594                 .channel_mode = alc269_modes,
14595                 .unsol_event = alc269_laptop_unsol_event,
14596                 .setup = alc269_laptop_amic_setup,
14597                 .init_hook = alc269_laptop_inithook,
14598         },
14599         [ALC269_DMIC] = {
14600                 .mixers = { alc269_laptop_mixer },
14601                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14602                 .init_verbs = { alc269_init_verbs,
14603                                 alc269_laptop_dmic_init_verbs },
14604                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14605                 .dac_nids = alc269_dac_nids,
14606                 .hp_nid = 0x03,
14607                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14608                 .channel_mode = alc269_modes,
14609                 .unsol_event = alc269_laptop_unsol_event,
14610                 .setup = alc269_laptop_dmic_setup,
14611                 .init_hook = alc269_laptop_inithook,
14612         },
14613         [ALC269VB_AMIC] = {
14614                 .mixers = { alc269vb_laptop_mixer },
14615                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14616                 .init_verbs = { alc269vb_init_verbs,
14617                                 alc269vb_laptop_amic_init_verbs },
14618                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14619                 .dac_nids = alc269_dac_nids,
14620                 .hp_nid = 0x03,
14621                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14622                 .channel_mode = alc269_modes,
14623                 .unsol_event = alc269_laptop_unsol_event,
14624                 .setup = alc269vb_laptop_amic_setup,
14625                 .init_hook = alc269_laptop_inithook,
14626         },
14627         [ALC269VB_DMIC] = {
14628                 .mixers = { alc269vb_laptop_mixer },
14629                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14630                 .init_verbs = { alc269vb_init_verbs,
14631                                 alc269vb_laptop_dmic_init_verbs },
14632                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14633                 .dac_nids = alc269_dac_nids,
14634                 .hp_nid = 0x03,
14635                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14636                 .channel_mode = alc269_modes,
14637                 .unsol_event = alc269_laptop_unsol_event,
14638                 .setup = alc269vb_laptop_dmic_setup,
14639                 .init_hook = alc269_laptop_inithook,
14640         },
14641         [ALC269_FUJITSU] = {
14642                 .mixers = { alc269_fujitsu_mixer },
14643                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14644                 .init_verbs = { alc269_init_verbs,
14645                                 alc269_laptop_dmic_init_verbs },
14646                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14647                 .dac_nids = alc269_dac_nids,
14648                 .hp_nid = 0x03,
14649                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14650                 .channel_mode = alc269_modes,
14651                 .unsol_event = alc269_laptop_unsol_event,
14652                 .setup = alc269_laptop_dmic_setup,
14653                 .init_hook = alc269_laptop_inithook,
14654         },
14655         [ALC269_LIFEBOOK] = {
14656                 .mixers = { alc269_lifebook_mixer },
14657                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14658                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14659                 .dac_nids = alc269_dac_nids,
14660                 .hp_nid = 0x03,
14661                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14662                 .channel_mode = alc269_modes,
14663                 .input_mux = &alc269_capture_source,
14664                 .unsol_event = alc269_lifebook_unsol_event,
14665                 .init_hook = alc269_lifebook_init_hook,
14666         },
14667         [ALC271_ACER] = {
14668                 .mixers = { alc269_asus_mixer },
14669                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14670                 .init_verbs = { alc269_init_verbs, alc271_acer_dmic_verbs },
14671                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14672                 .dac_nids = alc269_dac_nids,
14673                 .adc_nids = alc262_dmic_adc_nids,
14674                 .num_adc_nids = ARRAY_SIZE(alc262_dmic_adc_nids),
14675                 .capsrc_nids = alc262_dmic_capsrc_nids,
14676                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14677                 .channel_mode = alc269_modes,
14678                 .input_mux = &alc269_capture_source,
14679                 .dig_out_nid = ALC880_DIGOUT_NID,
14680                 .unsol_event = alc_sku_unsol_event,
14681                 .setup = alc269vb_laptop_dmic_setup,
14682                 .init_hook = alc_inithook,
14683         },
14684 };
14685
14686 static int patch_alc269(struct hda_codec *codec)
14687 {
14688         struct alc_spec *spec;
14689         int board_config;
14690         int err;
14691         int is_alc269vb = 0;
14692
14693         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14694         if (spec == NULL)
14695                 return -ENOMEM;
14696
14697         codec->spec = spec;
14698
14699         alc_auto_parse_customize_define(codec);
14700
14701         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14702                 if (codec->bus->pci->subsystem_vendor == 0x1025 &&
14703                     spec->cdefine.platform_type == 1)
14704                         alc_codec_rename(codec, "ALC271X");
14705                 else
14706                         alc_codec_rename(codec, "ALC259");
14707                 is_alc269vb = 1;
14708         } else
14709                 alc_fix_pll_init(codec, 0x20, 0x04, 15);
14710
14711         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14712                                                   alc269_models,
14713                                                   alc269_cfg_tbl);
14714
14715         if (board_config < 0) {
14716                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14717                        codec->chip_name);
14718                 board_config = ALC269_AUTO;
14719         }
14720
14721         if (board_config == ALC269_AUTO)
14722                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 1);
14723
14724         if (board_config == ALC269_AUTO) {
14725                 /* automatic parse from the BIOS config */
14726                 err = alc269_parse_auto_config(codec);
14727                 if (err < 0) {
14728                         alc_free(codec);
14729                         return err;
14730                 } else if (!err) {
14731                         printk(KERN_INFO
14732                                "hda_codec: Cannot set up configuration "
14733                                "from BIOS.  Using base mode...\n");
14734                         board_config = ALC269_BASIC;
14735                 }
14736         }
14737
14738         if (has_cdefine_beep(codec)) {
14739                 err = snd_hda_attach_beep_device(codec, 0x1);
14740                 if (err < 0) {
14741                         alc_free(codec);
14742                         return err;
14743                 }
14744         }
14745
14746         if (board_config != ALC269_AUTO)
14747                 setup_preset(codec, &alc269_presets[board_config]);
14748
14749         if (board_config == ALC269_QUANTA_FL1) {
14750                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
14751                  * fix the sample rate of analog I/O to 44.1kHz
14752                  */
14753                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
14754                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
14755         } else if (spec->dual_adc_switch) {
14756                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
14757                 /* switch ADC dynamically */
14758                 spec->stream_analog_capture = &dualmic_pcm_analog_capture;
14759         } else {
14760                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
14761                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
14762         }
14763         spec->stream_digital_playback = &alc269_pcm_digital_playback;
14764         spec->stream_digital_capture = &alc269_pcm_digital_capture;
14765
14766         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
14767                 if (!is_alc269vb) {
14768                         spec->adc_nids = alc269_adc_nids;
14769                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
14770                         spec->capsrc_nids = alc269_capsrc_nids;
14771                 } else {
14772                         spec->adc_nids = alc269vb_adc_nids;
14773                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
14774                         spec->capsrc_nids = alc269vb_capsrc_nids;
14775                 }
14776         }
14777
14778         if (!spec->cap_mixer)
14779                 set_capture_mixer(codec);
14780         if (has_cdefine_beep(codec))
14781                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
14782
14783         if (board_config == ALC269_AUTO)
14784                 alc_pick_fixup(codec, alc269_fixup_tbl, alc269_fixups, 0);
14785
14786         spec->vmaster_nid = 0x02;
14787
14788         codec->patch_ops = alc_patch_ops;
14789         if (board_config == ALC269_AUTO)
14790                 spec->init_hook = alc269_auto_init;
14791 #ifdef CONFIG_SND_HDA_POWER_SAVE
14792         if (!spec->loopback.amplist)
14793                 spec->loopback.amplist = alc269_loopbacks;
14794         if (alc269_mic2_for_mute_led(codec))
14795                 codec->patch_ops.check_power_status = alc269_mic2_mute_check_ps;
14796 #endif
14797
14798         return 0;
14799 }
14800
14801 /*
14802  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
14803  */
14804
14805 /*
14806  * set the path ways for 2 channel output
14807  * need to set the codec line out and mic 1 pin widgets to inputs
14808  */
14809 static struct hda_verb alc861_threestack_ch2_init[] = {
14810         /* set pin widget 1Ah (line in) for input */
14811         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14812         /* set pin widget 18h (mic1/2) for input, for mic also enable
14813          * the vref
14814          */
14815         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14816
14817         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14818 #if 0
14819         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14820         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14821 #endif
14822         { } /* end */
14823 };
14824 /*
14825  * 6ch mode
14826  * need to set the codec line out and mic 1 pin widgets to outputs
14827  */
14828 static struct hda_verb alc861_threestack_ch6_init[] = {
14829         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14830         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14831         /* set pin widget 18h (mic1) for output (CLFE)*/
14832         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14833
14834         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14835         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14836
14837         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14838 #if 0
14839         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14840         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14841 #endif
14842         { } /* end */
14843 };
14844
14845 static struct hda_channel_mode alc861_threestack_modes[2] = {
14846         { 2, alc861_threestack_ch2_init },
14847         { 6, alc861_threestack_ch6_init },
14848 };
14849 /* Set mic1 as input and unmute the mixer */
14850 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
14851         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14852         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14853         { } /* end */
14854 };
14855 /* Set mic1 as output and mute mixer */
14856 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
14857         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14858         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14859         { } /* end */
14860 };
14861
14862 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
14863         { 2, alc861_uniwill_m31_ch2_init },
14864         { 4, alc861_uniwill_m31_ch4_init },
14865 };
14866
14867 /* Set mic1 and line-in as input and unmute the mixer */
14868 static struct hda_verb alc861_asus_ch2_init[] = {
14869         /* set pin widget 1Ah (line in) for input */
14870         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14871         /* set pin widget 18h (mic1/2) for input, for mic also enable
14872          * the vref
14873          */
14874         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14875
14876         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14877 #if 0
14878         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14879         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14880 #endif
14881         { } /* end */
14882 };
14883 /* Set mic1 nad line-in as output and mute mixer */
14884 static struct hda_verb alc861_asus_ch6_init[] = {
14885         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14886         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14887         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14888         /* set pin widget 18h (mic1) for output (CLFE)*/
14889         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14890         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14891         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14892         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14893
14894         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14895 #if 0
14896         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14897         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14898 #endif
14899         { } /* end */
14900 };
14901
14902 static struct hda_channel_mode alc861_asus_modes[2] = {
14903         { 2, alc861_asus_ch2_init },
14904         { 6, alc861_asus_ch6_init },
14905 };
14906
14907 /* patch-ALC861 */
14908
14909 static struct snd_kcontrol_new alc861_base_mixer[] = {
14910         /* output mixer control */
14911         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14912         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14913         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14914         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14915         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14916
14917         /*Input mixer control */
14918         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14919            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14920         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14921         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14922         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14923         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14924         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14925         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14926         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14927         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14928
14929         { } /* end */
14930 };
14931
14932 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
14933         /* output mixer control */
14934         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14935         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14936         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14937         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14938         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14939
14940         /* Input mixer control */
14941         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14942            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14943         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14944         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14945         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14946         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14947         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14948         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14949         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14950         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14951
14952         {
14953                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14954                 .name = "Channel Mode",
14955                 .info = alc_ch_mode_info,
14956                 .get = alc_ch_mode_get,
14957                 .put = alc_ch_mode_put,
14958                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
14959         },
14960         { } /* end */
14961 };
14962
14963 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
14964         /* output mixer control */
14965         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14966         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14967         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14968
14969         { } /* end */
14970 };
14971
14972 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14973         /* output mixer control */
14974         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14975         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14976         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14977         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14978         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14979
14980         /* Input mixer control */
14981         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14982            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14983         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14984         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14985         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14986         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14987         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14988         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14989         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14990         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14991
14992         {
14993                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14994                 .name = "Channel Mode",
14995                 .info = alc_ch_mode_info,
14996                 .get = alc_ch_mode_get,
14997                 .put = alc_ch_mode_put,
14998                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14999         },
15000         { } /* end */
15001 };
15002
15003 static struct snd_kcontrol_new alc861_asus_mixer[] = {
15004         /* output mixer control */
15005         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
15006         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
15007         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
15008         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
15009         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
15010
15011         /* Input mixer control */
15012         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
15013         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
15014         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15015         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15016         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
15017         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
15018         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
15019         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
15020         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
15021         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
15022
15023         {
15024                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15025                 .name = "Channel Mode",
15026                 .info = alc_ch_mode_info,
15027                 .get = alc_ch_mode_get,
15028                 .put = alc_ch_mode_put,
15029                 .private_value = ARRAY_SIZE(alc861_asus_modes),
15030         },
15031         { }
15032 };
15033
15034 /* additional mixer */
15035 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
15036         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
15037         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
15038         { }
15039 };
15040
15041 /*
15042  * generic initialization of ADC, input mixers and output mixers
15043  */
15044 static struct hda_verb alc861_base_init_verbs[] = {
15045         /*
15046          * Unmute ADC0 and set the default input to mic-in
15047          */
15048         /* port-A for surround (rear panel) */
15049         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15050         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
15051         /* port-B for mic-in (rear panel) with vref */
15052         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15053         /* port-C for line-in (rear panel) */
15054         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15055         /* port-D for Front */
15056         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15057         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15058         /* port-E for HP out (front panel) */
15059         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15060         /* route front PCM to HP */
15061         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15062         /* port-F for mic-in (front panel) with vref */
15063         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15064         /* port-G for CLFE (rear panel) */
15065         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15066         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15067         /* port-H for side (rear panel) */
15068         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15069         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
15070         /* CD-in */
15071         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15072         /* route front mic to ADC1*/
15073         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15074         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15075
15076         /* Unmute DAC0~3 & spdif out*/
15077         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15078         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15079         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15080         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15081         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15082
15083         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15084         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15085         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15086         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15087         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15088
15089         /* Unmute Stereo Mixer 15 */
15090         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15091         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15092         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15093         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15094
15095         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15096         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15097         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15098         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15099         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15100         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15101         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15102         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15103         /* hp used DAC 3 (Front) */
15104         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15105         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15106
15107         { }
15108 };
15109
15110 static struct hda_verb alc861_threestack_init_verbs[] = {
15111         /*
15112          * Unmute ADC0 and set the default input to mic-in
15113          */
15114         /* port-A for surround (rear panel) */
15115         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15116         /* port-B for mic-in (rear panel) with vref */
15117         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15118         /* port-C for line-in (rear panel) */
15119         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15120         /* port-D for Front */
15121         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15122         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15123         /* port-E for HP out (front panel) */
15124         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
15125         /* route front PCM to HP */
15126         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15127         /* port-F for mic-in (front panel) with vref */
15128         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15129         /* port-G for CLFE (rear panel) */
15130         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15131         /* port-H for side (rear panel) */
15132         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15133         /* CD-in */
15134         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15135         /* route front mic to ADC1*/
15136         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15137         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15138         /* Unmute DAC0~3 & spdif out*/
15139         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15140         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15141         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15142         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15143         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15144
15145         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15146         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15147         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15148         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15149         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15150
15151         /* Unmute Stereo Mixer 15 */
15152         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15153         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15154         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15155         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15156
15157         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15158         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15159         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15160         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15161         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15162         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15163         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15164         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15165         /* hp used DAC 3 (Front) */
15166         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15167         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15168         { }
15169 };
15170
15171 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
15172         /*
15173          * Unmute ADC0 and set the default input to mic-in
15174          */
15175         /* port-A for surround (rear panel) */
15176         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15177         /* port-B for mic-in (rear panel) with vref */
15178         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15179         /* port-C for line-in (rear panel) */
15180         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15181         /* port-D for Front */
15182         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15183         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15184         /* port-E for HP out (front panel) */
15185         /* this has to be set to VREF80 */
15186         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15187         /* route front PCM to HP */
15188         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15189         /* port-F for mic-in (front panel) with vref */
15190         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15191         /* port-G for CLFE (rear panel) */
15192         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15193         /* port-H for side (rear panel) */
15194         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15195         /* CD-in */
15196         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15197         /* route front mic to ADC1*/
15198         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15199         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15200         /* Unmute DAC0~3 & spdif out*/
15201         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15202         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15203         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15204         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15205         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15206
15207         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15208         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15209         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15210         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15211         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15212
15213         /* Unmute Stereo Mixer 15 */
15214         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15215         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15216         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15217         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15218
15219         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15220         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15221         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15222         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15223         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15224         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15225         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15226         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15227         /* hp used DAC 3 (Front) */
15228         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15229         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15230         { }
15231 };
15232
15233 static struct hda_verb alc861_asus_init_verbs[] = {
15234         /*
15235          * Unmute ADC0 and set the default input to mic-in
15236          */
15237         /* port-A for surround (rear panel)
15238          * according to codec#0 this is the HP jack
15239          */
15240         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
15241         /* route front PCM to HP */
15242         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
15243         /* port-B for mic-in (rear panel) with vref */
15244         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15245         /* port-C for line-in (rear panel) */
15246         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15247         /* port-D for Front */
15248         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15249         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
15250         /* port-E for HP out (front panel) */
15251         /* this has to be set to VREF80 */
15252         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15253         /* route front PCM to HP */
15254         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
15255         /* port-F for mic-in (front panel) with vref */
15256         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
15257         /* port-G for CLFE (rear panel) */
15258         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15259         /* port-H for side (rear panel) */
15260         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
15261         /* CD-in */
15262         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
15263         /* route front mic to ADC1*/
15264         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
15265         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15266         /* Unmute DAC0~3 & spdif out*/
15267         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15268         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15269         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15270         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15271         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15272         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15273         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15274         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15275         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15276         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15277
15278         /* Unmute Stereo Mixer 15 */
15279         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15280         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15281         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15282         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
15283
15284         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15285         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15286         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15287         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15288         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15289         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15290         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15291         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15292         /* hp used DAC 3 (Front) */
15293         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
15294         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15295         { }
15296 };
15297
15298 /* additional init verbs for ASUS laptops */
15299 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
15300         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
15301         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
15302         { }
15303 };
15304
15305 /*
15306  * generic initialization of ADC, input mixers and output mixers
15307  */
15308 static struct hda_verb alc861_auto_init_verbs[] = {
15309         /*
15310          * Unmute ADC0 and set the default input to mic-in
15311          */
15312         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
15313         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15314
15315         /* Unmute DAC0~3 & spdif out*/
15316         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15317         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15318         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15319         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15320         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15321
15322         /* Unmute Mixer 14 (mic) 1c (Line in)*/
15323         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15324         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15325         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15326         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15327
15328         /* Unmute Stereo Mixer 15 */
15329         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15330         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15331         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15332         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
15333
15334         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15335         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15336         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15337         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15338         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15339         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15340         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15341         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15342
15343         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15344         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15345         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15346         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15347         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15348         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15349         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15350         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15351
15352         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
15353
15354         { }
15355 };
15356
15357 static struct hda_verb alc861_toshiba_init_verbs[] = {
15358         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15359
15360         { }
15361 };
15362
15363 /* toggle speaker-output according to the hp-jack state */
15364 static void alc861_toshiba_automute(struct hda_codec *codec)
15365 {
15366         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
15367
15368         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
15369                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
15370         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
15371                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
15372 }
15373
15374 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
15375                                        unsigned int res)
15376 {
15377         if ((res >> 26) == ALC880_HP_EVENT)
15378                 alc861_toshiba_automute(codec);
15379 }
15380
15381 /* pcm configuration: identical with ALC880 */
15382 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
15383 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
15384 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
15385 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
15386
15387
15388 #define ALC861_DIGOUT_NID       0x07
15389
15390 static struct hda_channel_mode alc861_8ch_modes[1] = {
15391         { 8, NULL }
15392 };
15393
15394 static hda_nid_t alc861_dac_nids[4] = {
15395         /* front, surround, clfe, side */
15396         0x03, 0x06, 0x05, 0x04
15397 };
15398
15399 static hda_nid_t alc660_dac_nids[3] = {
15400         /* front, clfe, surround */
15401         0x03, 0x05, 0x06
15402 };
15403
15404 static hda_nid_t alc861_adc_nids[1] = {
15405         /* ADC0-2 */
15406         0x08,
15407 };
15408
15409 static struct hda_input_mux alc861_capture_source = {
15410         .num_items = 5,
15411         .items = {
15412                 { "Mic", 0x0 },
15413                 { "Front Mic", 0x3 },
15414                 { "Line", 0x1 },
15415                 { "CD", 0x4 },
15416                 { "Mixer", 0x5 },
15417         },
15418 };
15419
15420 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
15421 {
15422         struct alc_spec *spec = codec->spec;
15423         hda_nid_t mix, srcs[5];
15424         int i, j, num;
15425
15426         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
15427                 return 0;
15428         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15429         if (num < 0)
15430                 return 0;
15431         for (i = 0; i < num; i++) {
15432                 unsigned int type;
15433                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
15434                 if (type != AC_WID_AUD_OUT)
15435                         continue;
15436                 for (j = 0; j < spec->multiout.num_dacs; j++)
15437                         if (spec->multiout.dac_nids[j] == srcs[i])
15438                                 break;
15439                 if (j >= spec->multiout.num_dacs)
15440                         return srcs[i];
15441         }
15442         return 0;
15443 }
15444
15445 /* fill in the dac_nids table from the parsed pin configuration */
15446 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
15447                                      const struct auto_pin_cfg *cfg)
15448 {
15449         struct alc_spec *spec = codec->spec;
15450         int i;
15451         hda_nid_t nid, dac;
15452
15453         spec->multiout.dac_nids = spec->private_dac_nids;
15454         for (i = 0; i < cfg->line_outs; i++) {
15455                 nid = cfg->line_out_pins[i];
15456                 dac = alc861_look_for_dac(codec, nid);
15457                 if (!dac)
15458                         continue;
15459                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
15460         }
15461         return 0;
15462 }
15463
15464 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
15465                                 hda_nid_t nid, unsigned int chs)
15466 {
15467         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
15468                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
15469 }
15470
15471 /* add playback controls from the parsed DAC table */
15472 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
15473                                              const struct auto_pin_cfg *cfg)
15474 {
15475         struct alc_spec *spec = codec->spec;
15476         static const char *chname[4] = {
15477                 "Front", "Surround", NULL /*CLFE*/, "Side"
15478         };
15479         hda_nid_t nid;
15480         int i, err;
15481
15482         if (cfg->line_outs == 1) {
15483                 const char *pfx = NULL;
15484                 if (!cfg->hp_outs)
15485                         pfx = "Master";
15486                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15487                         pfx = "Speaker";
15488                 if (pfx) {
15489                         nid = spec->multiout.dac_nids[0];
15490                         return alc861_create_out_sw(codec, pfx, nid, 3);
15491                 }
15492         }
15493
15494         for (i = 0; i < cfg->line_outs; i++) {
15495                 nid = spec->multiout.dac_nids[i];
15496                 if (!nid)
15497                         continue;
15498                 if (i == 2) {
15499                         /* Center/LFE */
15500                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15501                         if (err < 0)
15502                                 return err;
15503                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15504                         if (err < 0)
15505                                 return err;
15506                 } else {
15507                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
15508                         if (err < 0)
15509                                 return err;
15510                 }
15511         }
15512         return 0;
15513 }
15514
15515 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15516 {
15517         struct alc_spec *spec = codec->spec;
15518         int err;
15519         hda_nid_t nid;
15520
15521         if (!pin)
15522                 return 0;
15523
15524         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15525                 nid = alc861_look_for_dac(codec, pin);
15526                 if (nid) {
15527                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15528                         if (err < 0)
15529                                 return err;
15530                         spec->multiout.hp_nid = nid;
15531                 }
15532         }
15533         return 0;
15534 }
15535
15536 /* create playback/capture controls for input pins */
15537 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15538                                                 const struct auto_pin_cfg *cfg)
15539 {
15540         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15541 }
15542
15543 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15544                                               hda_nid_t nid,
15545                                               int pin_type, hda_nid_t dac)
15546 {
15547         hda_nid_t mix, srcs[5];
15548         int i, num;
15549
15550         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15551                             pin_type);
15552         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15553                             AMP_OUT_UNMUTE);
15554         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15555                 return;
15556         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15557         if (num < 0)
15558                 return;
15559         for (i = 0; i < num; i++) {
15560                 unsigned int mute;
15561                 if (srcs[i] == dac || srcs[i] == 0x15)
15562                         mute = AMP_IN_UNMUTE(i);
15563                 else
15564                         mute = AMP_IN_MUTE(i);
15565                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15566                                     mute);
15567         }
15568 }
15569
15570 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15571 {
15572         struct alc_spec *spec = codec->spec;
15573         int i;
15574
15575         for (i = 0; i < spec->autocfg.line_outs; i++) {
15576                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15577                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15578                 if (nid)
15579                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15580                                                           spec->multiout.dac_nids[i]);
15581         }
15582 }
15583
15584 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15585 {
15586         struct alc_spec *spec = codec->spec;
15587
15588         if (spec->autocfg.hp_outs)
15589                 alc861_auto_set_output_and_unmute(codec,
15590                                                   spec->autocfg.hp_pins[0],
15591                                                   PIN_HP,
15592                                                   spec->multiout.hp_nid);
15593         if (spec->autocfg.speaker_outs)
15594                 alc861_auto_set_output_and_unmute(codec,
15595                                                   spec->autocfg.speaker_pins[0],
15596                                                   PIN_OUT,
15597                                                   spec->multiout.dac_nids[0]);
15598 }
15599
15600 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15601 {
15602         struct alc_spec *spec = codec->spec;
15603         struct auto_pin_cfg *cfg = &spec->autocfg;
15604         int i;
15605
15606         for (i = 0; i < cfg->num_inputs; i++) {
15607                 hda_nid_t nid = cfg->inputs[i].pin;
15608                 if (nid >= 0x0c && nid <= 0x11)
15609                         alc_set_input_pin(codec, nid, i);
15610         }
15611 }
15612
15613 /* parse the BIOS configuration and set up the alc_spec */
15614 /* return 1 if successful, 0 if the proper config is not found,
15615  * or a negative error code
15616  */
15617 static int alc861_parse_auto_config(struct hda_codec *codec)
15618 {
15619         struct alc_spec *spec = codec->spec;
15620         int err;
15621         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15622
15623         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15624                                            alc861_ignore);
15625         if (err < 0)
15626                 return err;
15627         if (!spec->autocfg.line_outs)
15628                 return 0; /* can't find valid BIOS pin config */
15629
15630         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15631         if (err < 0)
15632                 return err;
15633         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15634         if (err < 0)
15635                 return err;
15636         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15637         if (err < 0)
15638                 return err;
15639         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15640         if (err < 0)
15641                 return err;
15642
15643         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15644
15645         alc_auto_parse_digital(codec);
15646
15647         if (spec->kctls.list)
15648                 add_mixer(spec, spec->kctls.list);
15649
15650         add_verb(spec, alc861_auto_init_verbs);
15651
15652         spec->num_mux_defs = 1;
15653         spec->input_mux = &spec->private_imux[0];
15654
15655         spec->adc_nids = alc861_adc_nids;
15656         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15657         set_capture_mixer(codec);
15658
15659         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15660
15661         return 1;
15662 }
15663
15664 /* additional initialization for auto-configuration model */
15665 static void alc861_auto_init(struct hda_codec *codec)
15666 {
15667         struct alc_spec *spec = codec->spec;
15668         alc861_auto_init_multi_out(codec);
15669         alc861_auto_init_hp_out(codec);
15670         alc861_auto_init_analog_input(codec);
15671         alc_auto_init_digital(codec);
15672         if (spec->unsol_event)
15673                 alc_inithook(codec);
15674 }
15675
15676 #ifdef CONFIG_SND_HDA_POWER_SAVE
15677 static struct hda_amp_list alc861_loopbacks[] = {
15678         { 0x15, HDA_INPUT, 0 },
15679         { 0x15, HDA_INPUT, 1 },
15680         { 0x15, HDA_INPUT, 2 },
15681         { 0x15, HDA_INPUT, 3 },
15682         { } /* end */
15683 };
15684 #endif
15685
15686
15687 /*
15688  * configuration and preset
15689  */
15690 static const char *alc861_models[ALC861_MODEL_LAST] = {
15691         [ALC861_3ST]            = "3stack",
15692         [ALC660_3ST]            = "3stack-660",
15693         [ALC861_3ST_DIG]        = "3stack-dig",
15694         [ALC861_6ST_DIG]        = "6stack-dig",
15695         [ALC861_UNIWILL_M31]    = "uniwill-m31",
15696         [ALC861_TOSHIBA]        = "toshiba",
15697         [ALC861_ASUS]           = "asus",
15698         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
15699         [ALC861_AUTO]           = "auto",
15700 };
15701
15702 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15703         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15704         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15705         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15706         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15707         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15708         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15709         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15710         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15711          *        Any other models that need this preset?
15712          */
15713         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15714         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
15715         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
15716         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
15717         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
15718         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
15719         /* FIXME: the below seems conflict */
15720         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
15721         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
15722         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
15723         {}
15724 };
15725
15726 static struct alc_config_preset alc861_presets[] = {
15727         [ALC861_3ST] = {
15728                 .mixers = { alc861_3ST_mixer },
15729                 .init_verbs = { alc861_threestack_init_verbs },
15730                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15731                 .dac_nids = alc861_dac_nids,
15732                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15733                 .channel_mode = alc861_threestack_modes,
15734                 .need_dac_fix = 1,
15735                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15736                 .adc_nids = alc861_adc_nids,
15737                 .input_mux = &alc861_capture_source,
15738         },
15739         [ALC861_3ST_DIG] = {
15740                 .mixers = { alc861_base_mixer },
15741                 .init_verbs = { alc861_threestack_init_verbs },
15742                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15743                 .dac_nids = alc861_dac_nids,
15744                 .dig_out_nid = ALC861_DIGOUT_NID,
15745                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15746                 .channel_mode = alc861_threestack_modes,
15747                 .need_dac_fix = 1,
15748                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15749                 .adc_nids = alc861_adc_nids,
15750                 .input_mux = &alc861_capture_source,
15751         },
15752         [ALC861_6ST_DIG] = {
15753                 .mixers = { alc861_base_mixer },
15754                 .init_verbs = { alc861_base_init_verbs },
15755                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15756                 .dac_nids = alc861_dac_nids,
15757                 .dig_out_nid = ALC861_DIGOUT_NID,
15758                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
15759                 .channel_mode = alc861_8ch_modes,
15760                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15761                 .adc_nids = alc861_adc_nids,
15762                 .input_mux = &alc861_capture_source,
15763         },
15764         [ALC660_3ST] = {
15765                 .mixers = { alc861_3ST_mixer },
15766                 .init_verbs = { alc861_threestack_init_verbs },
15767                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
15768                 .dac_nids = alc660_dac_nids,
15769                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15770                 .channel_mode = alc861_threestack_modes,
15771                 .need_dac_fix = 1,
15772                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15773                 .adc_nids = alc861_adc_nids,
15774                 .input_mux = &alc861_capture_source,
15775         },
15776         [ALC861_UNIWILL_M31] = {
15777                 .mixers = { alc861_uniwill_m31_mixer },
15778                 .init_verbs = { alc861_uniwill_m31_init_verbs },
15779                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15780                 .dac_nids = alc861_dac_nids,
15781                 .dig_out_nid = ALC861_DIGOUT_NID,
15782                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
15783                 .channel_mode = alc861_uniwill_m31_modes,
15784                 .need_dac_fix = 1,
15785                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15786                 .adc_nids = alc861_adc_nids,
15787                 .input_mux = &alc861_capture_source,
15788         },
15789         [ALC861_TOSHIBA] = {
15790                 .mixers = { alc861_toshiba_mixer },
15791                 .init_verbs = { alc861_base_init_verbs,
15792                                 alc861_toshiba_init_verbs },
15793                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15794                 .dac_nids = alc861_dac_nids,
15795                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15796                 .channel_mode = alc883_3ST_2ch_modes,
15797                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15798                 .adc_nids = alc861_adc_nids,
15799                 .input_mux = &alc861_capture_source,
15800                 .unsol_event = alc861_toshiba_unsol_event,
15801                 .init_hook = alc861_toshiba_automute,
15802         },
15803         [ALC861_ASUS] = {
15804                 .mixers = { alc861_asus_mixer },
15805                 .init_verbs = { alc861_asus_init_verbs },
15806                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15807                 .dac_nids = alc861_dac_nids,
15808                 .dig_out_nid = ALC861_DIGOUT_NID,
15809                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
15810                 .channel_mode = alc861_asus_modes,
15811                 .need_dac_fix = 1,
15812                 .hp_nid = 0x06,
15813                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15814                 .adc_nids = alc861_adc_nids,
15815                 .input_mux = &alc861_capture_source,
15816         },
15817         [ALC861_ASUS_LAPTOP] = {
15818                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
15819                 .init_verbs = { alc861_asus_init_verbs,
15820                                 alc861_asus_laptop_init_verbs },
15821                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15822                 .dac_nids = alc861_dac_nids,
15823                 .dig_out_nid = ALC861_DIGOUT_NID,
15824                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15825                 .channel_mode = alc883_3ST_2ch_modes,
15826                 .need_dac_fix = 1,
15827                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15828                 .adc_nids = alc861_adc_nids,
15829                 .input_mux = &alc861_capture_source,
15830         },
15831 };
15832
15833 /* Pin config fixes */
15834 enum {
15835         PINFIX_FSC_AMILO_PI1505,
15836 };
15837
15838 static const struct alc_fixup alc861_fixups[] = {
15839         [PINFIX_FSC_AMILO_PI1505] = {
15840                 .pins = (const struct alc_pincfg[]) {
15841                         { 0x0b, 0x0221101f }, /* HP */
15842                         { 0x0f, 0x90170310 }, /* speaker */
15843                         { }
15844                 }
15845         },
15846 };
15847
15848 static struct snd_pci_quirk alc861_fixup_tbl[] = {
15849         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
15850         {}
15851 };
15852
15853 static int patch_alc861(struct hda_codec *codec)
15854 {
15855         struct alc_spec *spec;
15856         int board_config;
15857         int err;
15858
15859         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15860         if (spec == NULL)
15861                 return -ENOMEM;
15862
15863         codec->spec = spec;
15864
15865         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
15866                                                   alc861_models,
15867                                                   alc861_cfg_tbl);
15868
15869         if (board_config < 0) {
15870                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15871                        codec->chip_name);
15872                 board_config = ALC861_AUTO;
15873         }
15874
15875         if (board_config == ALC861_AUTO)
15876                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 1);
15877
15878         if (board_config == ALC861_AUTO) {
15879                 /* automatic parse from the BIOS config */
15880                 err = alc861_parse_auto_config(codec);
15881                 if (err < 0) {
15882                         alc_free(codec);
15883                         return err;
15884                 } else if (!err) {
15885                         printk(KERN_INFO
15886                                "hda_codec: Cannot set up configuration "
15887                                "from BIOS.  Using base mode...\n");
15888                    board_config = ALC861_3ST_DIG;
15889                 }
15890         }
15891
15892         err = snd_hda_attach_beep_device(codec, 0x23);
15893         if (err < 0) {
15894                 alc_free(codec);
15895                 return err;
15896         }
15897
15898         if (board_config != ALC861_AUTO)
15899                 setup_preset(codec, &alc861_presets[board_config]);
15900
15901         spec->stream_analog_playback = &alc861_pcm_analog_playback;
15902         spec->stream_analog_capture = &alc861_pcm_analog_capture;
15903
15904         spec->stream_digital_playback = &alc861_pcm_digital_playback;
15905         spec->stream_digital_capture = &alc861_pcm_digital_capture;
15906
15907         if (!spec->cap_mixer)
15908                 set_capture_mixer(codec);
15909         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
15910
15911         spec->vmaster_nid = 0x03;
15912
15913         if (board_config == ALC861_AUTO)
15914                 alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups, 0);
15915
15916         codec->patch_ops = alc_patch_ops;
15917         if (board_config == ALC861_AUTO) {
15918                 spec->init_hook = alc861_auto_init;
15919 #ifdef CONFIG_SND_HDA_POWER_SAVE
15920                 spec->power_hook = alc_power_eapd;
15921 #endif
15922         }
15923 #ifdef CONFIG_SND_HDA_POWER_SAVE
15924         if (!spec->loopback.amplist)
15925                 spec->loopback.amplist = alc861_loopbacks;
15926 #endif
15927
15928         return 0;
15929 }
15930
15931 /*
15932  * ALC861-VD support
15933  *
15934  * Based on ALC882
15935  *
15936  * In addition, an independent DAC
15937  */
15938 #define ALC861VD_DIGOUT_NID     0x06
15939
15940 static hda_nid_t alc861vd_dac_nids[4] = {
15941         /* front, surr, clfe, side surr */
15942         0x02, 0x03, 0x04, 0x05
15943 };
15944
15945 /* dac_nids for ALC660vd are in a different order - according to
15946  * Realtek's driver.
15947  * This should probably result in a different mixer for 6stack models
15948  * of ALC660vd codecs, but for now there is only 3stack mixer
15949  * - and it is the same as in 861vd.
15950  * adc_nids in ALC660vd are (is) the same as in 861vd
15951  */
15952 static hda_nid_t alc660vd_dac_nids[3] = {
15953         /* front, rear, clfe, rear_surr */
15954         0x02, 0x04, 0x03
15955 };
15956
15957 static hda_nid_t alc861vd_adc_nids[1] = {
15958         /* ADC0 */
15959         0x09,
15960 };
15961
15962 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
15963
15964 /* input MUX */
15965 /* FIXME: should be a matrix-type input source selection */
15966 static struct hda_input_mux alc861vd_capture_source = {
15967         .num_items = 4,
15968         .items = {
15969                 { "Mic", 0x0 },
15970                 { "Front Mic", 0x1 },
15971                 { "Line", 0x2 },
15972                 { "CD", 0x4 },
15973         },
15974 };
15975
15976 static struct hda_input_mux alc861vd_dallas_capture_source = {
15977         .num_items = 2,
15978         .items = {
15979                 { "Ext Mic", 0x0 },
15980                 { "Int Mic", 0x1 },
15981         },
15982 };
15983
15984 static struct hda_input_mux alc861vd_hp_capture_source = {
15985         .num_items = 2,
15986         .items = {
15987                 { "Front Mic", 0x0 },
15988                 { "ATAPI Mic", 0x1 },
15989         },
15990 };
15991
15992 /*
15993  * 2ch mode
15994  */
15995 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15996         { 2, NULL }
15997 };
15998
15999 /*
16000  * 6ch mode
16001  */
16002 static struct hda_verb alc861vd_6stack_ch6_init[] = {
16003         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16004         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16005         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16006         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16007         { } /* end */
16008 };
16009
16010 /*
16011  * 8ch mode
16012  */
16013 static struct hda_verb alc861vd_6stack_ch8_init[] = {
16014         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16015         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16016         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16017         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16018         { } /* end */
16019 };
16020
16021 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
16022         { 6, alc861vd_6stack_ch6_init },
16023         { 8, alc861vd_6stack_ch8_init },
16024 };
16025
16026 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
16027         {
16028                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16029                 .name = "Channel Mode",
16030                 .info = alc_ch_mode_info,
16031                 .get = alc_ch_mode_get,
16032                 .put = alc_ch_mode_put,
16033         },
16034         { } /* end */
16035 };
16036
16037 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16038  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16039  */
16040 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
16041         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16042         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16043
16044         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16045         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
16046
16047         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
16048                                 HDA_OUTPUT),
16049         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
16050                                 HDA_OUTPUT),
16051         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
16052         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
16053
16054         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
16055         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
16056
16057         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16058
16059         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16060         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16061         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16062
16063         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16064         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16065         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16066
16067         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16068         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16069
16070         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16071         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16072
16073         { } /* end */
16074 };
16075
16076 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
16077         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16078         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16079
16080         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16081
16082         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16083         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16084         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16085
16086         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16087         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16088         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16089
16090         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16091         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16092
16093         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16094         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16095
16096         { } /* end */
16097 };
16098
16099 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
16100         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16101         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
16102         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16103
16104         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16105
16106         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
16107         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16108         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16109
16110         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
16111         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16112         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16113
16114         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16115         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16116
16117         { } /* end */
16118 };
16119
16120 /* Pin assignment: Speaker=0x14, HP = 0x15,
16121  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
16122  */
16123 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
16124         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16125         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
16126         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16127         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16128         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16129         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16130         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16131         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16132         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16133         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16134         { } /* end */
16135 };
16136
16137 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
16138  *                 Front Mic=0x18, ATAPI Mic = 0x19,
16139  */
16140 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
16141         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16142         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
16143         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16144         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
16145         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16146         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16147         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16148         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16149
16150         { } /* end */
16151 };
16152
16153 /*
16154  * generic initialization of ADC, input mixers and output mixers
16155  */
16156 static struct hda_verb alc861vd_volume_init_verbs[] = {
16157         /*
16158          * Unmute ADC0 and set the default input to mic-in
16159          */
16160         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16161         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16162
16163         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
16164          * the analog-loopback mixer widget
16165          */
16166         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16167         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16168         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16169         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16170         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16171         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16172
16173         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
16174         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16175         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16176         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
16177         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
16178
16179         /*
16180          * Set up output mixers (0x02 - 0x05)
16181          */
16182         /* set vol=0 to output mixers */
16183         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16184         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16185         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16186         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16187
16188         /* set up input amps for analog loopback */
16189         /* Amp Indices: DAC = 0, mixer = 1 */
16190         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16191         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16192         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16193         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16194         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16195         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16196         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16197         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16198
16199         { }
16200 };
16201
16202 /*
16203  * 3-stack pin configuration:
16204  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
16205  */
16206 static struct hda_verb alc861vd_3stack_init_verbs[] = {
16207         /*
16208          * Set pin mode and muting
16209          */
16210         /* set front pin widgets 0x14 for output */
16211         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16212         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16213         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16214
16215         /* Mic (rear) pin: input vref at 80% */
16216         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16217         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16218         /* Front Mic pin: input vref at 80% */
16219         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16220         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16221         /* Line In pin: input */
16222         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16223         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16224         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16225         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16226         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16227         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16228         /* CD pin widget for input */
16229         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16230
16231         { }
16232 };
16233
16234 /*
16235  * 6-stack pin configuration:
16236  */
16237 static struct hda_verb alc861vd_6stack_init_verbs[] = {
16238         /*
16239          * Set pin mode and muting
16240          */
16241         /* set front pin widgets 0x14 for output */
16242         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16243         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16244         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
16245
16246         /* Rear Pin: output 1 (0x0d) */
16247         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16248         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16249         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
16250         /* CLFE Pin: output 2 (0x0e) */
16251         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16252         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16253         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
16254         /* Side Pin: output 3 (0x0f) */
16255         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16256         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16257         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
16258
16259         /* Mic (rear) pin: input vref at 80% */
16260         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16261         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16262         /* Front Mic pin: input vref at 80% */
16263         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16264         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16265         /* Line In pin: input */
16266         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16267         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16268         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16269         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16270         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16271         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16272         /* CD pin widget for input */
16273         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16274
16275         { }
16276 };
16277
16278 static struct hda_verb alc861vd_eapd_verbs[] = {
16279         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16280         { }
16281 };
16282
16283 static struct hda_verb alc660vd_eapd_verbs[] = {
16284         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16285         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16286         { }
16287 };
16288
16289 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
16290         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16291         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16292         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
16293         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16294         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16295         {}
16296 };
16297
16298 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
16299 {
16300         unsigned int present;
16301         unsigned char bits;
16302
16303         present = snd_hda_jack_detect(codec, 0x18);
16304         bits = present ? HDA_AMP_MUTE : 0;
16305
16306         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
16307                                  HDA_AMP_MUTE, bits);
16308 }
16309
16310 static void alc861vd_lenovo_setup(struct hda_codec *codec)
16311 {
16312         struct alc_spec *spec = codec->spec;
16313         spec->autocfg.hp_pins[0] = 0x1b;
16314         spec->autocfg.speaker_pins[0] = 0x14;
16315 }
16316
16317 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
16318 {
16319         alc_automute_amp(codec);
16320         alc861vd_lenovo_mic_automute(codec);
16321 }
16322
16323 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
16324                                         unsigned int res)
16325 {
16326         switch (res >> 26) {
16327         case ALC880_MIC_EVENT:
16328                 alc861vd_lenovo_mic_automute(codec);
16329                 break;
16330         default:
16331                 alc_automute_amp_unsol_event(codec, res);
16332                 break;
16333         }
16334 }
16335
16336 static struct hda_verb alc861vd_dallas_verbs[] = {
16337         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16338         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16339         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16340         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16341
16342         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16343         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16344         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16345         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16346         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16347         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16348         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16349         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16350
16351         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16353         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16354         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16355         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16356         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16357         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16358         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16359
16360         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16361         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16362         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
16363         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16364         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16365         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16366         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16367         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16368
16369         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16370         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16371         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16372         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16373
16374         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16375         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16376         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16377
16378         { } /* end */
16379 };
16380
16381 /* toggle speaker-output according to the hp-jack state */
16382 static void alc861vd_dallas_setup(struct hda_codec *codec)
16383 {
16384         struct alc_spec *spec = codec->spec;
16385
16386         spec->autocfg.hp_pins[0] = 0x15;
16387         spec->autocfg.speaker_pins[0] = 0x14;
16388 }
16389
16390 #ifdef CONFIG_SND_HDA_POWER_SAVE
16391 #define alc861vd_loopbacks      alc880_loopbacks
16392 #endif
16393
16394 /* pcm configuration: identical with ALC880 */
16395 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
16396 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
16397 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
16398 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
16399
16400 /*
16401  * configuration and preset
16402  */
16403 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
16404         [ALC660VD_3ST]          = "3stack-660",
16405         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
16406         [ALC660VD_ASUS_V1S]     = "asus-v1s",
16407         [ALC861VD_3ST]          = "3stack",
16408         [ALC861VD_3ST_DIG]      = "3stack-digout",
16409         [ALC861VD_6ST_DIG]      = "6stack-digout",
16410         [ALC861VD_LENOVO]       = "lenovo",
16411         [ALC861VD_DALLAS]       = "dallas",
16412         [ALC861VD_HP]           = "hp",
16413         [ALC861VD_AUTO]         = "auto",
16414 };
16415
16416 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
16417         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
16418         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
16419         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
16420         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
16421         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
16422         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
16423         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
16424         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
16425         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
16426         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
16427         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
16428         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
16429         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
16430         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
16431         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
16432         {}
16433 };
16434
16435 static struct alc_config_preset alc861vd_presets[] = {
16436         [ALC660VD_3ST] = {
16437                 .mixers = { alc861vd_3st_mixer },
16438                 .init_verbs = { alc861vd_volume_init_verbs,
16439                                  alc861vd_3stack_init_verbs },
16440                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16441                 .dac_nids = alc660vd_dac_nids,
16442                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16443                 .channel_mode = alc861vd_3stack_2ch_modes,
16444                 .input_mux = &alc861vd_capture_source,
16445         },
16446         [ALC660VD_3ST_DIG] = {
16447                 .mixers = { alc861vd_3st_mixer },
16448                 .init_verbs = { alc861vd_volume_init_verbs,
16449                                  alc861vd_3stack_init_verbs },
16450                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16451                 .dac_nids = alc660vd_dac_nids,
16452                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16453                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16454                 .channel_mode = alc861vd_3stack_2ch_modes,
16455                 .input_mux = &alc861vd_capture_source,
16456         },
16457         [ALC861VD_3ST] = {
16458                 .mixers = { alc861vd_3st_mixer },
16459                 .init_verbs = { alc861vd_volume_init_verbs,
16460                                  alc861vd_3stack_init_verbs },
16461                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16462                 .dac_nids = alc861vd_dac_nids,
16463                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16464                 .channel_mode = alc861vd_3stack_2ch_modes,
16465                 .input_mux = &alc861vd_capture_source,
16466         },
16467         [ALC861VD_3ST_DIG] = {
16468                 .mixers = { alc861vd_3st_mixer },
16469                 .init_verbs = { alc861vd_volume_init_verbs,
16470                                  alc861vd_3stack_init_verbs },
16471                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16472                 .dac_nids = alc861vd_dac_nids,
16473                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16474                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16475                 .channel_mode = alc861vd_3stack_2ch_modes,
16476                 .input_mux = &alc861vd_capture_source,
16477         },
16478         [ALC861VD_6ST_DIG] = {
16479                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
16480                 .init_verbs = { alc861vd_volume_init_verbs,
16481                                 alc861vd_6stack_init_verbs },
16482                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16483                 .dac_nids = alc861vd_dac_nids,
16484                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16485                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16486                 .channel_mode = alc861vd_6stack_modes,
16487                 .input_mux = &alc861vd_capture_source,
16488         },
16489         [ALC861VD_LENOVO] = {
16490                 .mixers = { alc861vd_lenovo_mixer },
16491                 .init_verbs = { alc861vd_volume_init_verbs,
16492                                 alc861vd_3stack_init_verbs,
16493                                 alc861vd_eapd_verbs,
16494                                 alc861vd_lenovo_unsol_verbs },
16495                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16496                 .dac_nids = alc660vd_dac_nids,
16497                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16498                 .channel_mode = alc861vd_3stack_2ch_modes,
16499                 .input_mux = &alc861vd_capture_source,
16500                 .unsol_event = alc861vd_lenovo_unsol_event,
16501                 .setup = alc861vd_lenovo_setup,
16502                 .init_hook = alc861vd_lenovo_init_hook,
16503         },
16504         [ALC861VD_DALLAS] = {
16505                 .mixers = { alc861vd_dallas_mixer },
16506                 .init_verbs = { alc861vd_dallas_verbs },
16507                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16508                 .dac_nids = alc861vd_dac_nids,
16509                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16510                 .channel_mode = alc861vd_3stack_2ch_modes,
16511                 .input_mux = &alc861vd_dallas_capture_source,
16512                 .unsol_event = alc_automute_amp_unsol_event,
16513                 .setup = alc861vd_dallas_setup,
16514                 .init_hook = alc_automute_amp,
16515         },
16516         [ALC861VD_HP] = {
16517                 .mixers = { alc861vd_hp_mixer },
16518                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16519                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16520                 .dac_nids = alc861vd_dac_nids,
16521                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16522                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16523                 .channel_mode = alc861vd_3stack_2ch_modes,
16524                 .input_mux = &alc861vd_hp_capture_source,
16525                 .unsol_event = alc_automute_amp_unsol_event,
16526                 .setup = alc861vd_dallas_setup,
16527                 .init_hook = alc_automute_amp,
16528         },
16529         [ALC660VD_ASUS_V1S] = {
16530                 .mixers = { alc861vd_lenovo_mixer },
16531                 .init_verbs = { alc861vd_volume_init_verbs,
16532                                 alc861vd_3stack_init_verbs,
16533                                 alc861vd_eapd_verbs,
16534                                 alc861vd_lenovo_unsol_verbs },
16535                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16536                 .dac_nids = alc660vd_dac_nids,
16537                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16538                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16539                 .channel_mode = alc861vd_3stack_2ch_modes,
16540                 .input_mux = &alc861vd_capture_source,
16541                 .unsol_event = alc861vd_lenovo_unsol_event,
16542                 .setup = alc861vd_lenovo_setup,
16543                 .init_hook = alc861vd_lenovo_init_hook,
16544         },
16545 };
16546
16547 /*
16548  * BIOS auto configuration
16549  */
16550 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16551                                                 const struct auto_pin_cfg *cfg)
16552 {
16553         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16554 }
16555
16556
16557 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16558                                 hda_nid_t nid, int pin_type, int dac_idx)
16559 {
16560         alc_set_pin_output(codec, nid, pin_type);
16561 }
16562
16563 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16564 {
16565         struct alc_spec *spec = codec->spec;
16566         int i;
16567
16568         for (i = 0; i <= HDA_SIDE; i++) {
16569                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16570                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16571                 if (nid)
16572                         alc861vd_auto_set_output_and_unmute(codec, nid,
16573                                                             pin_type, i);
16574         }
16575 }
16576
16577
16578 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16579 {
16580         struct alc_spec *spec = codec->spec;
16581         hda_nid_t pin;
16582
16583         pin = spec->autocfg.hp_pins[0];
16584         if (pin) /* connect to front and use dac 0 */
16585                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16586         pin = spec->autocfg.speaker_pins[0];
16587         if (pin)
16588                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16589 }
16590
16591 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16592
16593 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16594 {
16595         struct alc_spec *spec = codec->spec;
16596         struct auto_pin_cfg *cfg = &spec->autocfg;
16597         int i;
16598
16599         for (i = 0; i < cfg->num_inputs; i++) {
16600                 hda_nid_t nid = cfg->inputs[i].pin;
16601                 if (alc_is_input_pin(codec, nid)) {
16602                         alc_set_input_pin(codec, nid, i);
16603                         if (nid != ALC861VD_PIN_CD_NID &&
16604                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16605                                 snd_hda_codec_write(codec, nid, 0,
16606                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16607                                                 AMP_OUT_MUTE);
16608                 }
16609         }
16610 }
16611
16612 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
16613
16614 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
16615 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
16616
16617 /* add playback controls from the parsed DAC table */
16618 /* Based on ALC880 version. But ALC861VD has separate,
16619  * different NIDs for mute/unmute switch and volume control */
16620 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16621                                              const struct auto_pin_cfg *cfg)
16622 {
16623         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16624         hda_nid_t nid_v, nid_s;
16625         int i, err;
16626
16627         for (i = 0; i < cfg->line_outs; i++) {
16628                 if (!spec->multiout.dac_nids[i])
16629                         continue;
16630                 nid_v = alc861vd_idx_to_mixer_vol(
16631                                 alc880_dac_to_idx(
16632                                         spec->multiout.dac_nids[i]));
16633                 nid_s = alc861vd_idx_to_mixer_switch(
16634                                 alc880_dac_to_idx(
16635                                         spec->multiout.dac_nids[i]));
16636
16637                 if (i == 2) {
16638                         /* Center/LFE */
16639                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16640                                               "Center",
16641                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16642                                                               HDA_OUTPUT));
16643                         if (err < 0)
16644                                 return err;
16645                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16646                                               "LFE",
16647                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16648                                                               HDA_OUTPUT));
16649                         if (err < 0)
16650                                 return err;
16651                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16652                                              "Center",
16653                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16654                                                               HDA_INPUT));
16655                         if (err < 0)
16656                                 return err;
16657                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16658                                              "LFE",
16659                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16660                                                               HDA_INPUT));
16661                         if (err < 0)
16662                                 return err;
16663                 } else {
16664                         const char *pfx;
16665                         if (cfg->line_outs == 1 &&
16666                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16667                                 if (!cfg->hp_pins)
16668                                         pfx = "Speaker";
16669                                 else
16670                                         pfx = "PCM";
16671                         } else
16672                                 pfx = chname[i];
16673                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16674                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16675                                                               HDA_OUTPUT));
16676                         if (err < 0)
16677                                 return err;
16678                         if (cfg->line_outs == 1 &&
16679                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16680                                 pfx = "Speaker";
16681                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16682                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16683                                                               HDA_INPUT));
16684                         if (err < 0)
16685                                 return err;
16686                 }
16687         }
16688         return 0;
16689 }
16690
16691 /* add playback controls for speaker and HP outputs */
16692 /* Based on ALC880 version. But ALC861VD has separate,
16693  * different NIDs for mute/unmute switch and volume control */
16694 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16695                                         hda_nid_t pin, const char *pfx)
16696 {
16697         hda_nid_t nid_v, nid_s;
16698         int err;
16699
16700         if (!pin)
16701                 return 0;
16702
16703         if (alc880_is_fixed_pin(pin)) {
16704                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16705                 /* specify the DAC as the extra output */
16706                 if (!spec->multiout.hp_nid)
16707                         spec->multiout.hp_nid = nid_v;
16708                 else
16709                         spec->multiout.extra_out_nid[0] = nid_v;
16710                 /* control HP volume/switch on the output mixer amp */
16711                 nid_v = alc861vd_idx_to_mixer_vol(
16712                                 alc880_fixed_pin_idx(pin));
16713                 nid_s = alc861vd_idx_to_mixer_switch(
16714                                 alc880_fixed_pin_idx(pin));
16715
16716                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16717                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
16718                 if (err < 0)
16719                         return err;
16720                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16721                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
16722                 if (err < 0)
16723                         return err;
16724         } else if (alc880_is_multi_pin(pin)) {
16725                 /* set manual connection */
16726                 /* we have only a switch on HP-out PIN */
16727                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
16728                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16729                 if (err < 0)
16730                         return err;
16731         }
16732         return 0;
16733 }
16734
16735 /* parse the BIOS configuration and set up the alc_spec
16736  * return 1 if successful, 0 if the proper config is not found,
16737  * or a negative error code
16738  * Based on ALC880 version - had to change it to override
16739  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
16740 static int alc861vd_parse_auto_config(struct hda_codec *codec)
16741 {
16742         struct alc_spec *spec = codec->spec;
16743         int err;
16744         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
16745
16746         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16747                                            alc861vd_ignore);
16748         if (err < 0)
16749                 return err;
16750         if (!spec->autocfg.line_outs)
16751                 return 0; /* can't find valid BIOS pin config */
16752
16753         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16754         if (err < 0)
16755                 return err;
16756         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
16757         if (err < 0)
16758                 return err;
16759         err = alc861vd_auto_create_extra_out(spec,
16760                                              spec->autocfg.speaker_pins[0],
16761                                              "Speaker");
16762         if (err < 0)
16763                 return err;
16764         err = alc861vd_auto_create_extra_out(spec,
16765                                              spec->autocfg.hp_pins[0],
16766                                              "Headphone");
16767         if (err < 0)
16768                 return err;
16769         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
16770         if (err < 0)
16771                 return err;
16772
16773         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16774
16775         alc_auto_parse_digital(codec);
16776
16777         if (spec->kctls.list)
16778                 add_mixer(spec, spec->kctls.list);
16779
16780         add_verb(spec, alc861vd_volume_init_verbs);
16781
16782         spec->num_mux_defs = 1;
16783         spec->input_mux = &spec->private_imux[0];
16784
16785         err = alc_auto_add_mic_boost(codec);
16786         if (err < 0)
16787                 return err;
16788
16789         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
16790
16791         return 1;
16792 }
16793
16794 /* additional initialization for auto-configuration model */
16795 static void alc861vd_auto_init(struct hda_codec *codec)
16796 {
16797         struct alc_spec *spec = codec->spec;
16798         alc861vd_auto_init_multi_out(codec);
16799         alc861vd_auto_init_hp_out(codec);
16800         alc861vd_auto_init_analog_input(codec);
16801         alc861vd_auto_init_input_src(codec);
16802         alc_auto_init_digital(codec);
16803         if (spec->unsol_event)
16804                 alc_inithook(codec);
16805 }
16806
16807 enum {
16808         ALC660VD_FIX_ASUS_GPIO1
16809 };
16810
16811 /* reset GPIO1 */
16812 static const struct alc_fixup alc861vd_fixups[] = {
16813         [ALC660VD_FIX_ASUS_GPIO1] = {
16814                 .verbs = (const struct hda_verb[]) {
16815                         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
16816                         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
16817                         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
16818                         { }
16819                 }
16820         },
16821 };
16822
16823 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
16824         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
16825         {}
16826 };
16827
16828 static int patch_alc861vd(struct hda_codec *codec)
16829 {
16830         struct alc_spec *spec;
16831         int err, board_config;
16832
16833         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16834         if (spec == NULL)
16835                 return -ENOMEM;
16836
16837         codec->spec = spec;
16838
16839         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
16840                                                   alc861vd_models,
16841                                                   alc861vd_cfg_tbl);
16842
16843         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
16844                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16845                        codec->chip_name);
16846                 board_config = ALC861VD_AUTO;
16847         }
16848
16849         if (board_config == ALC861VD_AUTO)
16850                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 1);
16851
16852         if (board_config == ALC861VD_AUTO) {
16853                 /* automatic parse from the BIOS config */
16854                 err = alc861vd_parse_auto_config(codec);
16855                 if (err < 0) {
16856                         alc_free(codec);
16857                         return err;
16858                 } else if (!err) {
16859                         printk(KERN_INFO
16860                                "hda_codec: Cannot set up configuration "
16861                                "from BIOS.  Using base mode...\n");
16862                         board_config = ALC861VD_3ST;
16863                 }
16864         }
16865
16866         err = snd_hda_attach_beep_device(codec, 0x23);
16867         if (err < 0) {
16868                 alc_free(codec);
16869                 return err;
16870         }
16871
16872         if (board_config != ALC861VD_AUTO)
16873                 setup_preset(codec, &alc861vd_presets[board_config]);
16874
16875         if (codec->vendor_id == 0x10ec0660) {
16876                 /* always turn on EAPD */
16877                 add_verb(spec, alc660vd_eapd_verbs);
16878         }
16879
16880         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
16881         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
16882
16883         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
16884         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
16885
16886         if (!spec->adc_nids) {
16887                 spec->adc_nids = alc861vd_adc_nids;
16888                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
16889         }
16890         if (!spec->capsrc_nids)
16891                 spec->capsrc_nids = alc861vd_capsrc_nids;
16892
16893         set_capture_mixer(codec);
16894         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16895
16896         spec->vmaster_nid = 0x02;
16897
16898         if (board_config == ALC861VD_AUTO)
16899                 alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups, 0);
16900
16901         codec->patch_ops = alc_patch_ops;
16902
16903         if (board_config == ALC861VD_AUTO)
16904                 spec->init_hook = alc861vd_auto_init;
16905 #ifdef CONFIG_SND_HDA_POWER_SAVE
16906         if (!spec->loopback.amplist)
16907                 spec->loopback.amplist = alc861vd_loopbacks;
16908 #endif
16909
16910         return 0;
16911 }
16912
16913 /*
16914  * ALC662 support
16915  *
16916  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
16917  * configuration.  Each pin widget can choose any input DACs and a mixer.
16918  * Each ADC is connected from a mixer of all inputs.  This makes possible
16919  * 6-channel independent captures.
16920  *
16921  * In addition, an independent DAC for the multi-playback (not used in this
16922  * driver yet).
16923  */
16924 #define ALC662_DIGOUT_NID       0x06
16925 #define ALC662_DIGIN_NID        0x0a
16926
16927 static hda_nid_t alc662_dac_nids[4] = {
16928         /* front, rear, clfe, rear_surr */
16929         0x02, 0x03, 0x04
16930 };
16931
16932 static hda_nid_t alc272_dac_nids[2] = {
16933         0x02, 0x03
16934 };
16935
16936 static hda_nid_t alc662_adc_nids[2] = {
16937         /* ADC1-2 */
16938         0x09, 0x08
16939 };
16940
16941 static hda_nid_t alc272_adc_nids[1] = {
16942         /* ADC1-2 */
16943         0x08,
16944 };
16945
16946 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
16947 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
16948
16949
16950 /* input MUX */
16951 /* FIXME: should be a matrix-type input source selection */
16952 static struct hda_input_mux alc662_capture_source = {
16953         .num_items = 4,
16954         .items = {
16955                 { "Mic", 0x0 },
16956                 { "Front Mic", 0x1 },
16957                 { "Line", 0x2 },
16958                 { "CD", 0x4 },
16959         },
16960 };
16961
16962 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
16963         .num_items = 2,
16964         .items = {
16965                 { "Mic", 0x1 },
16966                 { "Line", 0x2 },
16967         },
16968 };
16969
16970 static struct hda_input_mux alc663_capture_source = {
16971         .num_items = 3,
16972         .items = {
16973                 { "Mic", 0x0 },
16974                 { "Front Mic", 0x1 },
16975                 { "Line", 0x2 },
16976         },
16977 };
16978
16979 #if 0 /* set to 1 for testing other input sources below */
16980 static struct hda_input_mux alc272_nc10_capture_source = {
16981         .num_items = 16,
16982         .items = {
16983                 { "Autoselect Mic", 0x0 },
16984                 { "Internal Mic", 0x1 },
16985                 { "In-0x02", 0x2 },
16986                 { "In-0x03", 0x3 },
16987                 { "In-0x04", 0x4 },
16988                 { "In-0x05", 0x5 },
16989                 { "In-0x06", 0x6 },
16990                 { "In-0x07", 0x7 },
16991                 { "In-0x08", 0x8 },
16992                 { "In-0x09", 0x9 },
16993                 { "In-0x0a", 0x0a },
16994                 { "In-0x0b", 0x0b },
16995                 { "In-0x0c", 0x0c },
16996                 { "In-0x0d", 0x0d },
16997                 { "In-0x0e", 0x0e },
16998                 { "In-0x0f", 0x0f },
16999         },
17000 };
17001 #endif
17002
17003 /*
17004  * 2ch mode
17005  */
17006 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
17007         { 2, NULL }
17008 };
17009
17010 /*
17011  * 2ch mode
17012  */
17013 static struct hda_verb alc662_3ST_ch2_init[] = {
17014         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
17015         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17016         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
17017         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
17018         { } /* end */
17019 };
17020
17021 /*
17022  * 6ch mode
17023  */
17024 static struct hda_verb alc662_3ST_ch6_init[] = {
17025         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17026         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17027         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
17028         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17029         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
17030         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
17031         { } /* end */
17032 };
17033
17034 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
17035         { 2, alc662_3ST_ch2_init },
17036         { 6, alc662_3ST_ch6_init },
17037 };
17038
17039 /*
17040  * 2ch mode
17041  */
17042 static struct hda_verb alc662_sixstack_ch6_init[] = {
17043         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17044         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
17045         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17046         { } /* end */
17047 };
17048
17049 /*
17050  * 6ch mode
17051  */
17052 static struct hda_verb alc662_sixstack_ch8_init[] = {
17053         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17054         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17055         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
17056         { } /* end */
17057 };
17058
17059 static struct hda_channel_mode alc662_5stack_modes[2] = {
17060         { 2, alc662_sixstack_ch6_init },
17061         { 6, alc662_sixstack_ch8_init },
17062 };
17063
17064 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
17065  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
17066  */
17067
17068 static struct snd_kcontrol_new alc662_base_mixer[] = {
17069         /* output mixer control */
17070         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
17071         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17072         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
17073         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17074         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17075         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17076         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17077         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17078         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17079
17080         /*Input mixer control */
17081         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
17082         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
17083         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
17084         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
17085         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
17086         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
17087         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
17088         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
17089         { } /* end */
17090 };
17091
17092 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
17093         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17094         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17095         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17096         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17097         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17098         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17099         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17100         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17101         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17102         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17103         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17104         { } /* end */
17105 };
17106
17107 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
17108         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17109         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
17110         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17111         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
17112         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17113         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17114         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
17115         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
17116         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17117         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
17118         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
17119         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17120         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17121         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17122         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17123         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17124         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17125         { } /* end */
17126 };
17127
17128 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
17129         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17130         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
17131         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17132         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
17133         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17134         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17135         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17136         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17137         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17138         { } /* end */
17139 };
17140
17141 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
17142         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17143         ALC262_HIPPO_MASTER_SWITCH,
17144
17145         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
17146         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17147         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17148
17149         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17150         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17151         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17152         { } /* end */
17153 };
17154
17155 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
17156         ALC262_HIPPO_MASTER_SWITCH,
17157         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17158         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17159         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
17160         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
17161         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
17162         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17163         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17164         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17165         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17166         { } /* end */
17167 };
17168
17169 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
17170         .ops = &snd_hda_bind_vol,
17171         .values = {
17172                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17173                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
17174                 0
17175         },
17176 };
17177
17178 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
17179         .ops = &snd_hda_bind_sw,
17180         .values = {
17181                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17182                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17183                 0
17184         },
17185 };
17186
17187 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
17188         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17189         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
17190         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17191         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17192         { } /* end */
17193 };
17194
17195 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
17196         .ops = &snd_hda_bind_sw,
17197         .values = {
17198                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17199                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17200                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17201                 0
17202         },
17203 };
17204
17205 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
17206         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17207         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
17208         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17209         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17210         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17211         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17212
17213         { } /* end */
17214 };
17215
17216 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
17217         .ops = &snd_hda_bind_sw,
17218         .values = {
17219                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17220                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17221                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17222                 0
17223         },
17224 };
17225
17226 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
17227         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17228         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
17229         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17230         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17231         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17232         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17233         { } /* end */
17234 };
17235
17236 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
17237         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17238         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17239         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17242         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17243         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17244         { } /* end */
17245 };
17246
17247 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
17248         .ops = &snd_hda_bind_vol,
17249         .values = {
17250                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
17251                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
17252                 0
17253         },
17254 };
17255
17256 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
17257         .ops = &snd_hda_bind_sw,
17258         .values = {
17259                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17260                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
17261                 0
17262         },
17263 };
17264
17265 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
17266         HDA_BIND_VOL("Master Playback Volume",
17267                                 &alc663_asus_two_bind_master_vol),
17268         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17269         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17270         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17273         { } /* end */
17274 };
17275
17276 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
17277         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
17278         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
17279         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17280         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17281         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17282         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17283         { } /* end */
17284 };
17285
17286 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
17287         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17288         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17289         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17290         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17291         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17292
17293         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17294         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17295         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17296         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17297         { } /* end */
17298 };
17299
17300 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
17301         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17302         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17303         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17304
17305         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17306         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17307         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17308         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17309         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
17310         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
17311         { } /* end */
17312 };
17313
17314 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
17315         .ops = &snd_hda_bind_sw,
17316         .values = {
17317                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17318                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
17319                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17320                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
17321                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
17322                 0
17323         },
17324 };
17325
17326 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
17327         .ops = &snd_hda_bind_sw,
17328         .values = {
17329                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
17330                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
17331                 0
17332         },
17333 };
17334
17335 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
17336         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17337         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17338         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17339         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
17340         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17341         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17342         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17343         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17344         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17345         { } /* end */
17346 };
17347
17348 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
17349         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
17350         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
17351         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
17352         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
17353         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17354         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17355         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17356         { } /* end */
17357 };
17358
17359
17360 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
17361         {
17362                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
17363                 .name = "Channel Mode",
17364                 .info = alc_ch_mode_info,
17365                 .get = alc_ch_mode_get,
17366                 .put = alc_ch_mode_put,
17367         },
17368         { } /* end */
17369 };
17370
17371 static struct hda_verb alc662_init_verbs[] = {
17372         /* ADC: mute amp left and right */
17373         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17374         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
17375
17376         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17377         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17378         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17379         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17380         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17381         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17382
17383         /* Front Pin: output 0 (0x0c) */
17384         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17385         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17386
17387         /* Rear Pin: output 1 (0x0d) */
17388         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17389         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17390
17391         /* CLFE Pin: output 2 (0x0e) */
17392         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17393         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17394
17395         /* Mic (rear) pin: input vref at 80% */
17396         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17397         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17398         /* Front Mic pin: input vref at 80% */
17399         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
17400         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17401         /* Line In pin: input */
17402         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17403         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17404         /* Line-2 In: Headphone output (output 0 - 0x0c) */
17405         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17406         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17407         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
17408         /* CD pin widget for input */
17409         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17410
17411         /* FIXME: use matrix-type input source selection */
17412         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
17413         /* Input mixer */
17414         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17415         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17416
17417         /* always trun on EAPD */
17418         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
17419         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
17420
17421         { }
17422 };
17423
17424 static struct hda_verb alc663_init_verbs[] = {
17425         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17426         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17427         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17428         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17429         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17430         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17431         { }
17432 };
17433
17434 static struct hda_verb alc272_init_verbs[] = {
17435         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17436         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
17437         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17438         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17439         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17440         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17441         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
17442         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17443         { }
17444 };
17445
17446 static struct hda_verb alc662_sue_init_verbs[] = {
17447         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17448         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17449         {}
17450 };
17451
17452 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
17453         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17454         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17455         {}
17456 };
17457
17458 /* Set Unsolicited Event*/
17459 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
17460         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17461         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17462         {}
17463 };
17464
17465 static struct hda_verb alc663_m51va_init_verbs[] = {
17466         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17467         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17468         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17469         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17470         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17471         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17472         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17473         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17474         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17475         {}
17476 };
17477
17478 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
17479         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17480         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17481         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17483         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17484         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17485         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17486         {}
17487 };
17488
17489 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17490         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17491         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17492         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17493         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17494         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17495         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17496         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17497         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17498         {}
17499 };
17500
17501 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17502         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17503         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17504         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17505         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17506         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17507         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17508         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17509         {}
17510 };
17511
17512 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17513         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17514         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17515         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17516         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17517         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17518         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17519         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17520         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17521         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17522         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17523         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17524         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17525         {}
17526 };
17527
17528 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17529         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17530         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17531         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17532         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17533         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17534         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17535         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17536         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17537         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17538         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17539         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17540         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17541         {}
17542 };
17543
17544 static struct hda_verb alc663_g71v_init_verbs[] = {
17545         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17546         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17547         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17548
17549         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17550         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17551         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17552
17553         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17554         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17555         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17556         {}
17557 };
17558
17559 static struct hda_verb alc663_g50v_init_verbs[] = {
17560         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17561         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17562         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17563
17564         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17565         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17566         {}
17567 };
17568
17569 static struct hda_verb alc662_ecs_init_verbs[] = {
17570         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17571         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17572         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17573         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17574         {}
17575 };
17576
17577 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17578         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17579         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17580         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17581         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17582         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17583         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17584         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17585         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17586         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17587         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17588         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17589         {}
17590 };
17591
17592 static struct hda_verb alc272_dell_init_verbs[] = {
17593         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17594         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17595         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17596         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17597         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17598         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17599         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17600         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17601         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17602         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17603         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17604         {}
17605 };
17606
17607 static struct hda_verb alc663_mode7_init_verbs[] = {
17608         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17609         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17610         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17611         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17612         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17613         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17614         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17615         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17616         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17617         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17618         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17619         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17620         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17621         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17622         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17623         {}
17624 };
17625
17626 static struct hda_verb alc663_mode8_init_verbs[] = {
17627         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17628         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17629         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17630         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17631         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17632         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17633         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17634         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17635         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17636         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17637         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17638         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17639         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17640         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17641         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17642         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17643         {}
17644 };
17645
17646 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17647         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17648         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17649         { } /* end */
17650 };
17651
17652 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17653         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17654         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17655         { } /* end */
17656 };
17657
17658 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17659 {
17660         unsigned int present;
17661         unsigned char bits;
17662
17663         present = snd_hda_jack_detect(codec, 0x14);
17664         bits = present ? HDA_AMP_MUTE : 0;
17665
17666         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17667                                  HDA_AMP_MUTE, bits);
17668 }
17669
17670 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17671 {
17672         unsigned int present;
17673         unsigned char bits;
17674
17675         present = snd_hda_jack_detect(codec, 0x1b);
17676         bits = present ? HDA_AMP_MUTE : 0;
17677
17678         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17679                                  HDA_AMP_MUTE, bits);
17680         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17681                                  HDA_AMP_MUTE, bits);
17682 }
17683
17684 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17685                                            unsigned int res)
17686 {
17687         if ((res >> 26) == ALC880_HP_EVENT)
17688                 alc662_lenovo_101e_all_automute(codec);
17689         if ((res >> 26) == ALC880_FRONT_EVENT)
17690                 alc662_lenovo_101e_ispeaker_automute(codec);
17691 }
17692
17693 /* unsolicited event for HP jack sensing */
17694 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17695                                      unsigned int res)
17696 {
17697         if ((res >> 26) == ALC880_MIC_EVENT)
17698                 alc_mic_automute(codec);
17699         else
17700                 alc262_hippo_unsol_event(codec, res);
17701 }
17702
17703 static void alc662_eeepc_setup(struct hda_codec *codec)
17704 {
17705         struct alc_spec *spec = codec->spec;
17706
17707         alc262_hippo1_setup(codec);
17708         spec->ext_mic.pin = 0x18;
17709         spec->ext_mic.mux_idx = 0;
17710         spec->int_mic.pin = 0x19;
17711         spec->int_mic.mux_idx = 1;
17712         spec->auto_mic = 1;
17713 }
17714
17715 static void alc662_eeepc_inithook(struct hda_codec *codec)
17716 {
17717         alc262_hippo_automute(codec);
17718         alc_mic_automute(codec);
17719 }
17720
17721 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
17722 {
17723         struct alc_spec *spec = codec->spec;
17724
17725         spec->autocfg.hp_pins[0] = 0x14;
17726         spec->autocfg.speaker_pins[0] = 0x1b;
17727 }
17728
17729 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
17730
17731 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
17732 {
17733         unsigned int present;
17734         unsigned char bits;
17735
17736         present = snd_hda_jack_detect(codec, 0x21);
17737         bits = present ? HDA_AMP_MUTE : 0;
17738         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17739                                  HDA_AMP_MUTE, bits);
17740         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17741                                  HDA_AMP_MUTE, bits);
17742 }
17743
17744 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
17745 {
17746         unsigned int present;
17747         unsigned char bits;
17748
17749         present = snd_hda_jack_detect(codec, 0x21);
17750         bits = present ? HDA_AMP_MUTE : 0;
17751         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17752                                  HDA_AMP_MUTE, bits);
17753         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17754                                  HDA_AMP_MUTE, bits);
17755         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17756                                  HDA_AMP_MUTE, bits);
17757         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17758                                  HDA_AMP_MUTE, bits);
17759 }
17760
17761 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
17762 {
17763         unsigned int present;
17764         unsigned char bits;
17765
17766         present = snd_hda_jack_detect(codec, 0x15);
17767         bits = present ? HDA_AMP_MUTE : 0;
17768         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17769                                  HDA_AMP_MUTE, bits);
17770         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17771                                  HDA_AMP_MUTE, bits);
17772         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17773                                  HDA_AMP_MUTE, bits);
17774         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17775                                  HDA_AMP_MUTE, bits);
17776 }
17777
17778 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
17779 {
17780         unsigned int present;
17781         unsigned char bits;
17782
17783         present = snd_hda_jack_detect(codec, 0x1b);
17784         bits = present ? 0 : PIN_OUT;
17785         snd_hda_codec_write(codec, 0x14, 0,
17786                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
17787 }
17788
17789 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
17790 {
17791         unsigned int present1, present2;
17792
17793         present1 = snd_hda_jack_detect(codec, 0x21);
17794         present2 = snd_hda_jack_detect(codec, 0x15);
17795
17796         if (present1 || present2) {
17797                 snd_hda_codec_write_cache(codec, 0x14, 0,
17798                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17799         } else {
17800                 snd_hda_codec_write_cache(codec, 0x14, 0,
17801                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17802         }
17803 }
17804
17805 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
17806 {
17807         unsigned int present1, present2;
17808
17809         present1 = snd_hda_jack_detect(codec, 0x1b);
17810         present2 = snd_hda_jack_detect(codec, 0x15);
17811
17812         if (present1 || present2) {
17813                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17814                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17815                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17816                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17817         } else {
17818                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17819                                          HDA_AMP_MUTE, 0);
17820                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17821                                          HDA_AMP_MUTE, 0);
17822         }
17823 }
17824
17825 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
17826 {
17827         unsigned int present1, present2;
17828
17829         present1 = snd_hda_codec_read(codec, 0x1b, 0,
17830                         AC_VERB_GET_PIN_SENSE, 0)
17831                         & AC_PINSENSE_PRESENCE;
17832         present2 = snd_hda_codec_read(codec, 0x21, 0,
17833                         AC_VERB_GET_PIN_SENSE, 0)
17834                         & AC_PINSENSE_PRESENCE;
17835
17836         if (present1 || present2) {
17837                 snd_hda_codec_write_cache(codec, 0x14, 0,
17838                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17839                 snd_hda_codec_write_cache(codec, 0x17, 0,
17840                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17841         } else {
17842                 snd_hda_codec_write_cache(codec, 0x14, 0,
17843                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17844                 snd_hda_codec_write_cache(codec, 0x17, 0,
17845                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17846         }
17847 }
17848
17849 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
17850 {
17851         unsigned int present1, present2;
17852
17853         present1 = snd_hda_codec_read(codec, 0x21, 0,
17854                         AC_VERB_GET_PIN_SENSE, 0)
17855                         & AC_PINSENSE_PRESENCE;
17856         present2 = snd_hda_codec_read(codec, 0x15, 0,
17857                         AC_VERB_GET_PIN_SENSE, 0)
17858                         & AC_PINSENSE_PRESENCE;
17859
17860         if (present1 || present2) {
17861                 snd_hda_codec_write_cache(codec, 0x14, 0,
17862                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17863                 snd_hda_codec_write_cache(codec, 0x17, 0,
17864                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17865         } else {
17866                 snd_hda_codec_write_cache(codec, 0x14, 0,
17867                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17868                 snd_hda_codec_write_cache(codec, 0x17, 0,
17869                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17870         }
17871 }
17872
17873 static void alc663_m51va_unsol_event(struct hda_codec *codec,
17874                                            unsigned int res)
17875 {
17876         switch (res >> 26) {
17877         case ALC880_HP_EVENT:
17878                 alc663_m51va_speaker_automute(codec);
17879                 break;
17880         case ALC880_MIC_EVENT:
17881                 alc_mic_automute(codec);
17882                 break;
17883         }
17884 }
17885
17886 static void alc663_m51va_setup(struct hda_codec *codec)
17887 {
17888         struct alc_spec *spec = codec->spec;
17889         spec->ext_mic.pin = 0x18;
17890         spec->ext_mic.mux_idx = 0;
17891         spec->int_mic.pin = 0x12;
17892         spec->int_mic.mux_idx = 9;
17893         spec->auto_mic = 1;
17894 }
17895
17896 static void alc663_m51va_inithook(struct hda_codec *codec)
17897 {
17898         alc663_m51va_speaker_automute(codec);
17899         alc_mic_automute(codec);
17900 }
17901
17902 /* ***************** Mode1 ******************************/
17903 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
17904
17905 static void alc663_mode1_setup(struct hda_codec *codec)
17906 {
17907         struct alc_spec *spec = codec->spec;
17908         spec->ext_mic.pin = 0x18;
17909         spec->ext_mic.mux_idx = 0;
17910         spec->int_mic.pin = 0x19;
17911         spec->int_mic.mux_idx = 1;
17912         spec->auto_mic = 1;
17913 }
17914
17915 #define alc663_mode1_inithook           alc663_m51va_inithook
17916
17917 /* ***************** Mode2 ******************************/
17918 static void alc662_mode2_unsol_event(struct hda_codec *codec,
17919                                            unsigned int res)
17920 {
17921         switch (res >> 26) {
17922         case ALC880_HP_EVENT:
17923                 alc662_f5z_speaker_automute(codec);
17924                 break;
17925         case ALC880_MIC_EVENT:
17926                 alc_mic_automute(codec);
17927                 break;
17928         }
17929 }
17930
17931 #define alc662_mode2_setup      alc663_mode1_setup
17932
17933 static void alc662_mode2_inithook(struct hda_codec *codec)
17934 {
17935         alc662_f5z_speaker_automute(codec);
17936         alc_mic_automute(codec);
17937 }
17938 /* ***************** Mode3 ******************************/
17939 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17940                                            unsigned int res)
17941 {
17942         switch (res >> 26) {
17943         case ALC880_HP_EVENT:
17944                 alc663_two_hp_m1_speaker_automute(codec);
17945                 break;
17946         case ALC880_MIC_EVENT:
17947                 alc_mic_automute(codec);
17948                 break;
17949         }
17950 }
17951
17952 #define alc663_mode3_setup      alc663_mode1_setup
17953
17954 static void alc663_mode3_inithook(struct hda_codec *codec)
17955 {
17956         alc663_two_hp_m1_speaker_automute(codec);
17957         alc_mic_automute(codec);
17958 }
17959 /* ***************** Mode4 ******************************/
17960 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17961                                            unsigned int res)
17962 {
17963         switch (res >> 26) {
17964         case ALC880_HP_EVENT:
17965                 alc663_21jd_two_speaker_automute(codec);
17966                 break;
17967         case ALC880_MIC_EVENT:
17968                 alc_mic_automute(codec);
17969                 break;
17970         }
17971 }
17972
17973 #define alc663_mode4_setup      alc663_mode1_setup
17974
17975 static void alc663_mode4_inithook(struct hda_codec *codec)
17976 {
17977         alc663_21jd_two_speaker_automute(codec);
17978         alc_mic_automute(codec);
17979 }
17980 /* ***************** Mode5 ******************************/
17981 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17982                                            unsigned int res)
17983 {
17984         switch (res >> 26) {
17985         case ALC880_HP_EVENT:
17986                 alc663_15jd_two_speaker_automute(codec);
17987                 break;
17988         case ALC880_MIC_EVENT:
17989                 alc_mic_automute(codec);
17990                 break;
17991         }
17992 }
17993
17994 #define alc663_mode5_setup      alc663_mode1_setup
17995
17996 static void alc663_mode5_inithook(struct hda_codec *codec)
17997 {
17998         alc663_15jd_two_speaker_automute(codec);
17999         alc_mic_automute(codec);
18000 }
18001 /* ***************** Mode6 ******************************/
18002 static void alc663_mode6_unsol_event(struct hda_codec *codec,
18003                                            unsigned int res)
18004 {
18005         switch (res >> 26) {
18006         case ALC880_HP_EVENT:
18007                 alc663_two_hp_m2_speaker_automute(codec);
18008                 break;
18009         case ALC880_MIC_EVENT:
18010                 alc_mic_automute(codec);
18011                 break;
18012         }
18013 }
18014
18015 #define alc663_mode6_setup      alc663_mode1_setup
18016
18017 static void alc663_mode6_inithook(struct hda_codec *codec)
18018 {
18019         alc663_two_hp_m2_speaker_automute(codec);
18020         alc_mic_automute(codec);
18021 }
18022
18023 /* ***************** Mode7 ******************************/
18024 static void alc663_mode7_unsol_event(struct hda_codec *codec,
18025                                            unsigned int res)
18026 {
18027         switch (res >> 26) {
18028         case ALC880_HP_EVENT:
18029                 alc663_two_hp_m7_speaker_automute(codec);
18030                 break;
18031         case ALC880_MIC_EVENT:
18032                 alc_mic_automute(codec);
18033                 break;
18034         }
18035 }
18036
18037 #define alc663_mode7_setup      alc663_mode1_setup
18038
18039 static void alc663_mode7_inithook(struct hda_codec *codec)
18040 {
18041         alc663_two_hp_m7_speaker_automute(codec);
18042         alc_mic_automute(codec);
18043 }
18044
18045 /* ***************** Mode8 ******************************/
18046 static void alc663_mode8_unsol_event(struct hda_codec *codec,
18047                                            unsigned int res)
18048 {
18049         switch (res >> 26) {
18050         case ALC880_HP_EVENT:
18051                 alc663_two_hp_m8_speaker_automute(codec);
18052                 break;
18053         case ALC880_MIC_EVENT:
18054                 alc_mic_automute(codec);
18055                 break;
18056         }
18057 }
18058
18059 #define alc663_mode8_setup      alc663_m51va_setup
18060
18061 static void alc663_mode8_inithook(struct hda_codec *codec)
18062 {
18063         alc663_two_hp_m8_speaker_automute(codec);
18064         alc_mic_automute(codec);
18065 }
18066
18067 static void alc663_g71v_hp_automute(struct hda_codec *codec)
18068 {
18069         unsigned int present;
18070         unsigned char bits;
18071
18072         present = snd_hda_jack_detect(codec, 0x21);
18073         bits = present ? HDA_AMP_MUTE : 0;
18074         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
18075                                  HDA_AMP_MUTE, bits);
18076         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18077                                  HDA_AMP_MUTE, bits);
18078 }
18079
18080 static void alc663_g71v_front_automute(struct hda_codec *codec)
18081 {
18082         unsigned int present;
18083         unsigned char bits;
18084
18085         present = snd_hda_jack_detect(codec, 0x15);
18086         bits = present ? HDA_AMP_MUTE : 0;
18087         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
18088                                  HDA_AMP_MUTE, bits);
18089 }
18090
18091 static void alc663_g71v_unsol_event(struct hda_codec *codec,
18092                                            unsigned int res)
18093 {
18094         switch (res >> 26) {
18095         case ALC880_HP_EVENT:
18096                 alc663_g71v_hp_automute(codec);
18097                 break;
18098         case ALC880_FRONT_EVENT:
18099                 alc663_g71v_front_automute(codec);
18100                 break;
18101         case ALC880_MIC_EVENT:
18102                 alc_mic_automute(codec);
18103                 break;
18104         }
18105 }
18106
18107 #define alc663_g71v_setup       alc663_m51va_setup
18108
18109 static void alc663_g71v_inithook(struct hda_codec *codec)
18110 {
18111         alc663_g71v_front_automute(codec);
18112         alc663_g71v_hp_automute(codec);
18113         alc_mic_automute(codec);
18114 }
18115
18116 static void alc663_g50v_unsol_event(struct hda_codec *codec,
18117                                            unsigned int res)
18118 {
18119         switch (res >> 26) {
18120         case ALC880_HP_EVENT:
18121                 alc663_m51va_speaker_automute(codec);
18122                 break;
18123         case ALC880_MIC_EVENT:
18124                 alc_mic_automute(codec);
18125                 break;
18126         }
18127 }
18128
18129 #define alc663_g50v_setup       alc663_m51va_setup
18130
18131 static void alc663_g50v_inithook(struct hda_codec *codec)
18132 {
18133         alc663_m51va_speaker_automute(codec);
18134         alc_mic_automute(codec);
18135 }
18136
18137 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
18138         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18139         ALC262_HIPPO_MASTER_SWITCH,
18140
18141         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
18142         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
18143         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
18144
18145         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
18146         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18147         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18148         { } /* end */
18149 };
18150
18151 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
18152         /* Master Playback automatically created from Speaker and Headphone */
18153         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
18154         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
18155         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
18156         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
18157
18158         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
18159         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
18160         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
18161
18162         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
18163         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
18164         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
18165         { } /* end */
18166 };
18167
18168 #ifdef CONFIG_SND_HDA_POWER_SAVE
18169 #define alc662_loopbacks        alc880_loopbacks
18170 #endif
18171
18172
18173 /* pcm configuration: identical with ALC880 */
18174 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
18175 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
18176 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
18177 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
18178
18179 /*
18180  * configuration and preset
18181  */
18182 static const char *alc662_models[ALC662_MODEL_LAST] = {
18183         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
18184         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
18185         [ALC662_3ST_6ch]        = "3stack-6ch",
18186         [ALC662_5ST_DIG]        = "6stack-dig",
18187         [ALC662_LENOVO_101E]    = "lenovo-101e",
18188         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
18189         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
18190         [ALC662_ECS] = "ecs",
18191         [ALC663_ASUS_M51VA] = "m51va",
18192         [ALC663_ASUS_G71V] = "g71v",
18193         [ALC663_ASUS_H13] = "h13",
18194         [ALC663_ASUS_G50V] = "g50v",
18195         [ALC663_ASUS_MODE1] = "asus-mode1",
18196         [ALC662_ASUS_MODE2] = "asus-mode2",
18197         [ALC663_ASUS_MODE3] = "asus-mode3",
18198         [ALC663_ASUS_MODE4] = "asus-mode4",
18199         [ALC663_ASUS_MODE5] = "asus-mode5",
18200         [ALC663_ASUS_MODE6] = "asus-mode6",
18201         [ALC663_ASUS_MODE7] = "asus-mode7",
18202         [ALC663_ASUS_MODE8] = "asus-mode8",
18203         [ALC272_DELL]           = "dell",
18204         [ALC272_DELL_ZM1]       = "dell-zm1",
18205         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
18206         [ALC662_AUTO]           = "auto",
18207 };
18208
18209 static struct snd_pci_quirk alc662_cfg_tbl[] = {
18210         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
18211         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
18212         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
18213         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
18214         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
18215         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
18216         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
18217         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
18218         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
18219         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
18220         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
18221         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
18222         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
18223         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
18224         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
18225         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
18226         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
18227         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
18228         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
18229         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
18230         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
18231         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
18232         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
18233         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
18234         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
18235         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
18236         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
18237         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
18238         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
18239         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
18240         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
18241         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
18242         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
18243         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
18244         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
18245         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
18246         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
18247         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
18248         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
18249         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
18250         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
18251         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
18252         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
18253         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
18254         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
18255         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
18256         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
18257         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
18258         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
18259         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
18260         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
18261         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
18262         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
18263         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
18264         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
18265         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
18266         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
18267         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
18268         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
18269         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
18270         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
18271         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
18272         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
18273         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
18274                       ALC662_3ST_6ch_DIG),
18275         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
18276         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
18277         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
18278                       ALC662_3ST_6ch_DIG),
18279         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
18280         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
18281         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
18282         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
18283         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
18284                                         ALC662_3ST_6ch_DIG),
18285         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
18286                            ALC663_ASUS_H13),
18287         {}
18288 };
18289
18290 static struct alc_config_preset alc662_presets[] = {
18291         [ALC662_3ST_2ch_DIG] = {
18292                 .mixers = { alc662_3ST_2ch_mixer },
18293                 .init_verbs = { alc662_init_verbs },
18294                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18295                 .dac_nids = alc662_dac_nids,
18296                 .dig_out_nid = ALC662_DIGOUT_NID,
18297                 .dig_in_nid = ALC662_DIGIN_NID,
18298                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18299                 .channel_mode = alc662_3ST_2ch_modes,
18300                 .input_mux = &alc662_capture_source,
18301         },
18302         [ALC662_3ST_6ch_DIG] = {
18303                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18304                 .init_verbs = { alc662_init_verbs },
18305                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18306                 .dac_nids = alc662_dac_nids,
18307                 .dig_out_nid = ALC662_DIGOUT_NID,
18308                 .dig_in_nid = ALC662_DIGIN_NID,
18309                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18310                 .channel_mode = alc662_3ST_6ch_modes,
18311                 .need_dac_fix = 1,
18312                 .input_mux = &alc662_capture_source,
18313         },
18314         [ALC662_3ST_6ch] = {
18315                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
18316                 .init_verbs = { alc662_init_verbs },
18317                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18318                 .dac_nids = alc662_dac_nids,
18319                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18320                 .channel_mode = alc662_3ST_6ch_modes,
18321                 .need_dac_fix = 1,
18322                 .input_mux = &alc662_capture_source,
18323         },
18324         [ALC662_5ST_DIG] = {
18325                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
18326                 .init_verbs = { alc662_init_verbs },
18327                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18328                 .dac_nids = alc662_dac_nids,
18329                 .dig_out_nid = ALC662_DIGOUT_NID,
18330                 .dig_in_nid = ALC662_DIGIN_NID,
18331                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
18332                 .channel_mode = alc662_5stack_modes,
18333                 .input_mux = &alc662_capture_source,
18334         },
18335         [ALC662_LENOVO_101E] = {
18336                 .mixers = { alc662_lenovo_101e_mixer },
18337                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
18338                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18339                 .dac_nids = alc662_dac_nids,
18340                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18341                 .channel_mode = alc662_3ST_2ch_modes,
18342                 .input_mux = &alc662_lenovo_101e_capture_source,
18343                 .unsol_event = alc662_lenovo_101e_unsol_event,
18344                 .init_hook = alc662_lenovo_101e_all_automute,
18345         },
18346         [ALC662_ASUS_EEEPC_P701] = {
18347                 .mixers = { alc662_eeepc_p701_mixer },
18348                 .init_verbs = { alc662_init_verbs,
18349                                 alc662_eeepc_sue_init_verbs },
18350                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18351                 .dac_nids = alc662_dac_nids,
18352                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18353                 .channel_mode = alc662_3ST_2ch_modes,
18354                 .unsol_event = alc662_eeepc_unsol_event,
18355                 .setup = alc662_eeepc_setup,
18356                 .init_hook = alc662_eeepc_inithook,
18357         },
18358         [ALC662_ASUS_EEEPC_EP20] = {
18359                 .mixers = { alc662_eeepc_ep20_mixer,
18360                             alc662_chmode_mixer },
18361                 .init_verbs = { alc662_init_verbs,
18362                                 alc662_eeepc_ep20_sue_init_verbs },
18363                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18364                 .dac_nids = alc662_dac_nids,
18365                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18366                 .channel_mode = alc662_3ST_6ch_modes,
18367                 .input_mux = &alc662_lenovo_101e_capture_source,
18368                 .unsol_event = alc662_eeepc_unsol_event,
18369                 .setup = alc662_eeepc_ep20_setup,
18370                 .init_hook = alc662_eeepc_ep20_inithook,
18371         },
18372         [ALC662_ECS] = {
18373                 .mixers = { alc662_ecs_mixer },
18374                 .init_verbs = { alc662_init_verbs,
18375                                 alc662_ecs_init_verbs },
18376                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18377                 .dac_nids = alc662_dac_nids,
18378                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18379                 .channel_mode = alc662_3ST_2ch_modes,
18380                 .unsol_event = alc662_eeepc_unsol_event,
18381                 .setup = alc662_eeepc_setup,
18382                 .init_hook = alc662_eeepc_inithook,
18383         },
18384         [ALC663_ASUS_M51VA] = {
18385                 .mixers = { alc663_m51va_mixer },
18386                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18387                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18388                 .dac_nids = alc662_dac_nids,
18389                 .dig_out_nid = ALC662_DIGOUT_NID,
18390                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18391                 .channel_mode = alc662_3ST_2ch_modes,
18392                 .unsol_event = alc663_m51va_unsol_event,
18393                 .setup = alc663_m51va_setup,
18394                 .init_hook = alc663_m51va_inithook,
18395         },
18396         [ALC663_ASUS_G71V] = {
18397                 .mixers = { alc663_g71v_mixer },
18398                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
18399                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18400                 .dac_nids = alc662_dac_nids,
18401                 .dig_out_nid = ALC662_DIGOUT_NID,
18402                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18403                 .channel_mode = alc662_3ST_2ch_modes,
18404                 .unsol_event = alc663_g71v_unsol_event,
18405                 .setup = alc663_g71v_setup,
18406                 .init_hook = alc663_g71v_inithook,
18407         },
18408         [ALC663_ASUS_H13] = {
18409                 .mixers = { alc663_m51va_mixer },
18410                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
18411                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18412                 .dac_nids = alc662_dac_nids,
18413                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18414                 .channel_mode = alc662_3ST_2ch_modes,
18415                 .unsol_event = alc663_m51va_unsol_event,
18416                 .init_hook = alc663_m51va_inithook,
18417         },
18418         [ALC663_ASUS_G50V] = {
18419                 .mixers = { alc663_g50v_mixer },
18420                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
18421                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18422                 .dac_nids = alc662_dac_nids,
18423                 .dig_out_nid = ALC662_DIGOUT_NID,
18424                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
18425                 .channel_mode = alc662_3ST_6ch_modes,
18426                 .input_mux = &alc663_capture_source,
18427                 .unsol_event = alc663_g50v_unsol_event,
18428                 .setup = alc663_g50v_setup,
18429                 .init_hook = alc663_g50v_inithook,
18430         },
18431         [ALC663_ASUS_MODE1] = {
18432                 .mixers = { alc663_m51va_mixer },
18433                 .cap_mixer = alc662_auto_capture_mixer,
18434                 .init_verbs = { alc662_init_verbs,
18435                                 alc663_21jd_amic_init_verbs },
18436                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18437                 .hp_nid = 0x03,
18438                 .dac_nids = alc662_dac_nids,
18439                 .dig_out_nid = ALC662_DIGOUT_NID,
18440                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18441                 .channel_mode = alc662_3ST_2ch_modes,
18442                 .unsol_event = alc663_mode1_unsol_event,
18443                 .setup = alc663_mode1_setup,
18444                 .init_hook = alc663_mode1_inithook,
18445         },
18446         [ALC662_ASUS_MODE2] = {
18447                 .mixers = { alc662_1bjd_mixer },
18448                 .cap_mixer = alc662_auto_capture_mixer,
18449                 .init_verbs = { alc662_init_verbs,
18450                                 alc662_1bjd_amic_init_verbs },
18451                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18452                 .dac_nids = alc662_dac_nids,
18453                 .dig_out_nid = ALC662_DIGOUT_NID,
18454                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18455                 .channel_mode = alc662_3ST_2ch_modes,
18456                 .unsol_event = alc662_mode2_unsol_event,
18457                 .setup = alc662_mode2_setup,
18458                 .init_hook = alc662_mode2_inithook,
18459         },
18460         [ALC663_ASUS_MODE3] = {
18461                 .mixers = { alc663_two_hp_m1_mixer },
18462                 .cap_mixer = alc662_auto_capture_mixer,
18463                 .init_verbs = { alc662_init_verbs,
18464                                 alc663_two_hp_amic_m1_init_verbs },
18465                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18466                 .hp_nid = 0x03,
18467                 .dac_nids = alc662_dac_nids,
18468                 .dig_out_nid = ALC662_DIGOUT_NID,
18469                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18470                 .channel_mode = alc662_3ST_2ch_modes,
18471                 .unsol_event = alc663_mode3_unsol_event,
18472                 .setup = alc663_mode3_setup,
18473                 .init_hook = alc663_mode3_inithook,
18474         },
18475         [ALC663_ASUS_MODE4] = {
18476                 .mixers = { alc663_asus_21jd_clfe_mixer },
18477                 .cap_mixer = alc662_auto_capture_mixer,
18478                 .init_verbs = { alc662_init_verbs,
18479                                 alc663_21jd_amic_init_verbs},
18480                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18481                 .hp_nid = 0x03,
18482                 .dac_nids = alc662_dac_nids,
18483                 .dig_out_nid = ALC662_DIGOUT_NID,
18484                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18485                 .channel_mode = alc662_3ST_2ch_modes,
18486                 .unsol_event = alc663_mode4_unsol_event,
18487                 .setup = alc663_mode4_setup,
18488                 .init_hook = alc663_mode4_inithook,
18489         },
18490         [ALC663_ASUS_MODE5] = {
18491                 .mixers = { alc663_asus_15jd_clfe_mixer },
18492                 .cap_mixer = alc662_auto_capture_mixer,
18493                 .init_verbs = { alc662_init_verbs,
18494                                 alc663_15jd_amic_init_verbs },
18495                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18496                 .hp_nid = 0x03,
18497                 .dac_nids = alc662_dac_nids,
18498                 .dig_out_nid = ALC662_DIGOUT_NID,
18499                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18500                 .channel_mode = alc662_3ST_2ch_modes,
18501                 .unsol_event = alc663_mode5_unsol_event,
18502                 .setup = alc663_mode5_setup,
18503                 .init_hook = alc663_mode5_inithook,
18504         },
18505         [ALC663_ASUS_MODE6] = {
18506                 .mixers = { alc663_two_hp_m2_mixer },
18507                 .cap_mixer = alc662_auto_capture_mixer,
18508                 .init_verbs = { alc662_init_verbs,
18509                                 alc663_two_hp_amic_m2_init_verbs },
18510                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18511                 .hp_nid = 0x03,
18512                 .dac_nids = alc662_dac_nids,
18513                 .dig_out_nid = ALC662_DIGOUT_NID,
18514                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18515                 .channel_mode = alc662_3ST_2ch_modes,
18516                 .unsol_event = alc663_mode6_unsol_event,
18517                 .setup = alc663_mode6_setup,
18518                 .init_hook = alc663_mode6_inithook,
18519         },
18520         [ALC663_ASUS_MODE7] = {
18521                 .mixers = { alc663_mode7_mixer },
18522                 .cap_mixer = alc662_auto_capture_mixer,
18523                 .init_verbs = { alc662_init_verbs,
18524                                 alc663_mode7_init_verbs },
18525                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18526                 .hp_nid = 0x03,
18527                 .dac_nids = alc662_dac_nids,
18528                 .dig_out_nid = ALC662_DIGOUT_NID,
18529                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18530                 .channel_mode = alc662_3ST_2ch_modes,
18531                 .unsol_event = alc663_mode7_unsol_event,
18532                 .setup = alc663_mode7_setup,
18533                 .init_hook = alc663_mode7_inithook,
18534         },
18535         [ALC663_ASUS_MODE8] = {
18536                 .mixers = { alc663_mode8_mixer },
18537                 .cap_mixer = alc662_auto_capture_mixer,
18538                 .init_verbs = { alc662_init_verbs,
18539                                 alc663_mode8_init_verbs },
18540                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18541                 .hp_nid = 0x03,
18542                 .dac_nids = alc662_dac_nids,
18543                 .dig_out_nid = ALC662_DIGOUT_NID,
18544                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18545                 .channel_mode = alc662_3ST_2ch_modes,
18546                 .unsol_event = alc663_mode8_unsol_event,
18547                 .setup = alc663_mode8_setup,
18548                 .init_hook = alc663_mode8_inithook,
18549         },
18550         [ALC272_DELL] = {
18551                 .mixers = { alc663_m51va_mixer },
18552                 .cap_mixer = alc272_auto_capture_mixer,
18553                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18554                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18555                 .dac_nids = alc662_dac_nids,
18556                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18557                 .adc_nids = alc272_adc_nids,
18558                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18559                 .capsrc_nids = alc272_capsrc_nids,
18560                 .channel_mode = alc662_3ST_2ch_modes,
18561                 .unsol_event = alc663_m51va_unsol_event,
18562                 .setup = alc663_m51va_setup,
18563                 .init_hook = alc663_m51va_inithook,
18564         },
18565         [ALC272_DELL_ZM1] = {
18566                 .mixers = { alc663_m51va_mixer },
18567                 .cap_mixer = alc662_auto_capture_mixer,
18568                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18569                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18570                 .dac_nids = alc662_dac_nids,
18571                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18572                 .adc_nids = alc662_adc_nids,
18573                 .num_adc_nids = 1,
18574                 .capsrc_nids = alc662_capsrc_nids,
18575                 .channel_mode = alc662_3ST_2ch_modes,
18576                 .unsol_event = alc663_m51va_unsol_event,
18577                 .setup = alc663_m51va_setup,
18578                 .init_hook = alc663_m51va_inithook,
18579         },
18580         [ALC272_SAMSUNG_NC10] = {
18581                 .mixers = { alc272_nc10_mixer },
18582                 .init_verbs = { alc662_init_verbs,
18583                                 alc663_21jd_amic_init_verbs },
18584                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18585                 .dac_nids = alc272_dac_nids,
18586                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18587                 .channel_mode = alc662_3ST_2ch_modes,
18588                 /*.input_mux = &alc272_nc10_capture_source,*/
18589                 .unsol_event = alc663_mode4_unsol_event,
18590                 .setup = alc663_mode4_setup,
18591                 .init_hook = alc663_mode4_inithook,
18592         },
18593 };
18594
18595
18596 /*
18597  * BIOS auto configuration
18598  */
18599
18600 /* convert from MIX nid to DAC */
18601 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18602 {
18603         if (nid == 0x0f)
18604                 return 0x02;
18605         else if (nid >= 0x0c && nid <= 0x0e)
18606                 return nid - 0x0c + 0x02;
18607         else
18608                 return 0;
18609 }
18610
18611 /* get MIX nid connected to the given pin targeted to DAC */
18612 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18613                                    hda_nid_t dac)
18614 {
18615         hda_nid_t mix[4];
18616         int i, num;
18617
18618         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18619         for (i = 0; i < num; i++) {
18620                 if (alc662_mix_to_dac(mix[i]) == dac)
18621                         return mix[i];
18622         }
18623         return 0;
18624 }
18625
18626 /* look for an empty DAC slot */
18627 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18628 {
18629         struct alc_spec *spec = codec->spec;
18630         hda_nid_t srcs[5];
18631         int i, j, num;
18632
18633         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18634         if (num < 0)
18635                 return 0;
18636         for (i = 0; i < num; i++) {
18637                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18638                 if (!nid)
18639                         continue;
18640                 for (j = 0; j < spec->multiout.num_dacs; j++)
18641                         if (spec->multiout.dac_nids[j] == nid)
18642                                 break;
18643                 if (j >= spec->multiout.num_dacs)
18644                         return nid;
18645         }
18646         return 0;
18647 }
18648
18649 /* fill in the dac_nids table from the parsed pin configuration */
18650 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18651                                      const struct auto_pin_cfg *cfg)
18652 {
18653         struct alc_spec *spec = codec->spec;
18654         int i;
18655         hda_nid_t dac;
18656
18657         spec->multiout.dac_nids = spec->private_dac_nids;
18658         for (i = 0; i < cfg->line_outs; i++) {
18659                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18660                 if (!dac)
18661                         continue;
18662                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18663         }
18664         return 0;
18665 }
18666
18667 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18668                               hda_nid_t nid, unsigned int chs)
18669 {
18670         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18671                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18672 }
18673
18674 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18675                              hda_nid_t nid, unsigned int chs)
18676 {
18677         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18678                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18679 }
18680
18681 #define alc662_add_stereo_vol(spec, pfx, nid) \
18682         alc662_add_vol_ctl(spec, pfx, nid, 3)
18683 #define alc662_add_stereo_sw(spec, pfx, nid) \
18684         alc662_add_sw_ctl(spec, pfx, nid, 3)
18685
18686 /* add playback controls from the parsed DAC table */
18687 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18688                                              const struct auto_pin_cfg *cfg)
18689 {
18690         struct alc_spec *spec = codec->spec;
18691         static const char *chname[4] = {
18692                 "Front", "Surround", NULL /*CLFE*/, "Side"
18693         };
18694         hda_nid_t nid, mix;
18695         int i, err;
18696
18697         for (i = 0; i < cfg->line_outs; i++) {
18698                 nid = spec->multiout.dac_nids[i];
18699                 if (!nid)
18700                         continue;
18701                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18702                 if (!mix)
18703                         continue;
18704                 if (i == 2) {
18705                         /* Center/LFE */
18706                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18707                         if (err < 0)
18708                                 return err;
18709                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18710                         if (err < 0)
18711                                 return err;
18712                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18713                         if (err < 0)
18714                                 return err;
18715                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
18716                         if (err < 0)
18717                                 return err;
18718                 } else {
18719                         const char *pfx;
18720                         if (cfg->line_outs == 1 &&
18721                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
18722                                 if (cfg->hp_outs)
18723                                         pfx = "Speaker";
18724                                 else
18725                                         pfx = "PCM";
18726                         } else
18727                                 pfx = chname[i];
18728                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18729                         if (err < 0)
18730                                 return err;
18731                         if (cfg->line_outs == 1 &&
18732                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
18733                                 pfx = "Speaker";
18734                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18735                         if (err < 0)
18736                                 return err;
18737                 }
18738         }
18739         return 0;
18740 }
18741
18742 /* add playback controls for speaker and HP outputs */
18743 /* return DAC nid if any new DAC is assigned */
18744 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
18745                                         const char *pfx)
18746 {
18747         struct alc_spec *spec = codec->spec;
18748         hda_nid_t nid, mix;
18749         int err;
18750
18751         if (!pin)
18752                 return 0;
18753         nid = alc662_look_for_dac(codec, pin);
18754         if (!nid) {
18755                 /* the corresponding DAC is already occupied */
18756                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
18757                         return 0; /* no way */
18758                 /* create a switch only */
18759                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18760                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
18761         }
18762
18763         mix = alc662_dac_to_mix(codec, pin, nid);
18764         if (!mix)
18765                 return 0;
18766         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18767         if (err < 0)
18768                 return err;
18769         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18770         if (err < 0)
18771                 return err;
18772         return nid;
18773 }
18774
18775 /* create playback/capture controls for input pins */
18776 #define alc662_auto_create_input_ctls \
18777         alc882_auto_create_input_ctls
18778
18779 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
18780                                               hda_nid_t nid, int pin_type,
18781                                               hda_nid_t dac)
18782 {
18783         int i, num;
18784         hda_nid_t srcs[HDA_MAX_CONNECTIONS];
18785
18786         alc_set_pin_output(codec, nid, pin_type);
18787         /* need the manual connection? */
18788         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
18789         if (num <= 1)
18790                 return;
18791         for (i = 0; i < num; i++) {
18792                 if (alc662_mix_to_dac(srcs[i]) != dac)
18793                         continue;
18794                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
18795                 return;
18796         }
18797 }
18798
18799 static void alc662_auto_init_multi_out(struct hda_codec *codec)
18800 {
18801         struct alc_spec *spec = codec->spec;
18802         int pin_type = get_pin_type(spec->autocfg.line_out_type);
18803         int i;
18804
18805         for (i = 0; i <= HDA_SIDE; i++) {
18806                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
18807                 if (nid)
18808                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
18809                                         spec->multiout.dac_nids[i]);
18810         }
18811 }
18812
18813 static void alc662_auto_init_hp_out(struct hda_codec *codec)
18814 {
18815         struct alc_spec *spec = codec->spec;
18816         hda_nid_t pin;
18817
18818         pin = spec->autocfg.hp_pins[0];
18819         if (pin)
18820                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
18821                                                   spec->multiout.hp_nid);
18822         pin = spec->autocfg.speaker_pins[0];
18823         if (pin)
18824                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
18825                                         spec->multiout.extra_out_nid[0]);
18826 }
18827
18828 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
18829
18830 static void alc662_auto_init_analog_input(struct hda_codec *codec)
18831 {
18832         struct alc_spec *spec = codec->spec;
18833         struct auto_pin_cfg *cfg = &spec->autocfg;
18834         int i;
18835
18836         for (i = 0; i < cfg->num_inputs; i++) {
18837                 hda_nid_t nid = cfg->inputs[i].pin;
18838                 if (alc_is_input_pin(codec, nid)) {
18839                         alc_set_input_pin(codec, nid, i);
18840                         if (nid != ALC662_PIN_CD_NID &&
18841                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
18842                                 snd_hda_codec_write(codec, nid, 0,
18843                                                     AC_VERB_SET_AMP_GAIN_MUTE,
18844                                                     AMP_OUT_MUTE);
18845                 }
18846         }
18847 }
18848
18849 #define alc662_auto_init_input_src      alc882_auto_init_input_src
18850
18851 static int alc662_parse_auto_config(struct hda_codec *codec)
18852 {
18853         struct alc_spec *spec = codec->spec;
18854         int err;
18855         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
18856
18857         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
18858                                            alc662_ignore);
18859         if (err < 0)
18860                 return err;
18861         if (!spec->autocfg.line_outs)
18862                 return 0; /* can't find valid BIOS pin config */
18863
18864         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
18865         if (err < 0)
18866                 return err;
18867         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
18868         if (err < 0)
18869                 return err;
18870         err = alc662_auto_create_extra_out(codec,
18871                                            spec->autocfg.speaker_pins[0],
18872                                            "Speaker");
18873         if (err < 0)
18874                 return err;
18875         if (err)
18876                 spec->multiout.extra_out_nid[0] = err;
18877         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
18878                                            "Headphone");
18879         if (err < 0)
18880                 return err;
18881         if (err)
18882                 spec->multiout.hp_nid = err;
18883         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
18884         if (err < 0)
18885                 return err;
18886
18887         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
18888
18889         alc_auto_parse_digital(codec);
18890
18891         if (spec->kctls.list)
18892                 add_mixer(spec, spec->kctls.list);
18893
18894         spec->num_mux_defs = 1;
18895         spec->input_mux = &spec->private_imux[0];
18896
18897         add_verb(spec, alc662_init_verbs);
18898         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18899             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18900                 add_verb(spec, alc663_init_verbs);
18901
18902         if (codec->vendor_id == 0x10ec0272)
18903                 add_verb(spec, alc272_init_verbs);
18904
18905         err = alc_auto_add_mic_boost(codec);
18906         if (err < 0)
18907                 return err;
18908
18909         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18910             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18911             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
18912         else
18913             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
18914
18915         return 1;
18916 }
18917
18918 /* additional initialization for auto-configuration model */
18919 static void alc662_auto_init(struct hda_codec *codec)
18920 {
18921         struct alc_spec *spec = codec->spec;
18922         alc662_auto_init_multi_out(codec);
18923         alc662_auto_init_hp_out(codec);
18924         alc662_auto_init_analog_input(codec);
18925         alc662_auto_init_input_src(codec);
18926         alc_auto_init_digital(codec);
18927         if (spec->unsol_event)
18928                 alc_inithook(codec);
18929 }
18930
18931 static int patch_alc662(struct hda_codec *codec)
18932 {
18933         struct alc_spec *spec;
18934         int err, board_config;
18935
18936         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
18937         if (!spec)
18938                 return -ENOMEM;
18939
18940         codec->spec = spec;
18941
18942         alc_auto_parse_customize_define(codec);
18943
18944         alc_fix_pll_init(codec, 0x20, 0x04, 15);
18945
18946         if (alc_read_coef_idx(codec, 0) == 0x8020)
18947                 alc_codec_rename(codec, "ALC661");
18948         else if ((alc_read_coef_idx(codec, 0) & (1 << 14)) &&
18949                  codec->bus->pci->subsystem_vendor == 0x1025 &&
18950                  spec->cdefine.platform_type == 1)
18951                 alc_codec_rename(codec, "ALC272X");
18952
18953         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18954                                                   alc662_models,
18955                                                   alc662_cfg_tbl);
18956         if (board_config < 0) {
18957                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18958                        codec->chip_name);
18959                 board_config = ALC662_AUTO;
18960         }
18961
18962         if (board_config == ALC662_AUTO) {
18963                 /* automatic parse from the BIOS config */
18964                 err = alc662_parse_auto_config(codec);
18965                 if (err < 0) {
18966                         alc_free(codec);
18967                         return err;
18968                 } else if (!err) {
18969                         printk(KERN_INFO
18970                                "hda_codec: Cannot set up configuration "
18971                                "from BIOS.  Using base mode...\n");
18972                         board_config = ALC662_3ST_2ch_DIG;
18973                 }
18974         }
18975
18976         if (has_cdefine_beep(codec)) {
18977                 err = snd_hda_attach_beep_device(codec, 0x1);
18978                 if (err < 0) {
18979                         alc_free(codec);
18980                         return err;
18981                 }
18982         }
18983
18984         if (board_config != ALC662_AUTO)
18985                 setup_preset(codec, &alc662_presets[board_config]);
18986
18987         spec->stream_analog_playback = &alc662_pcm_analog_playback;
18988         spec->stream_analog_capture = &alc662_pcm_analog_capture;
18989
18990         spec->stream_digital_playback = &alc662_pcm_digital_playback;
18991         spec->stream_digital_capture = &alc662_pcm_digital_capture;
18992
18993         if (!spec->adc_nids) {
18994                 spec->adc_nids = alc662_adc_nids;
18995                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18996         }
18997         if (!spec->capsrc_nids)
18998                 spec->capsrc_nids = alc662_capsrc_nids;
18999
19000         if (!spec->cap_mixer)
19001                 set_capture_mixer(codec);
19002
19003         if (has_cdefine_beep(codec)) {
19004                 switch (codec->vendor_id) {
19005                 case 0x10ec0662:
19006                         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
19007                         break;
19008                 case 0x10ec0272:
19009                 case 0x10ec0663:
19010                 case 0x10ec0665:
19011                         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
19012                         break;
19013                 case 0x10ec0273:
19014                         set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
19015                         break;
19016                 }
19017         }
19018         spec->vmaster_nid = 0x02;
19019
19020         codec->patch_ops = alc_patch_ops;
19021         if (board_config == ALC662_AUTO)
19022                 spec->init_hook = alc662_auto_init;
19023 #ifdef CONFIG_SND_HDA_POWER_SAVE
19024         if (!spec->loopback.amplist)
19025                 spec->loopback.amplist = alc662_loopbacks;
19026 #endif
19027
19028         return 0;
19029 }
19030
19031 static int patch_alc888(struct hda_codec *codec)
19032 {
19033         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
19034                 kfree(codec->chip_name);
19035                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
19036                 if (!codec->chip_name) {
19037                         alc_free(codec);
19038                         return -ENOMEM;
19039                 }
19040                 return patch_alc662(codec);
19041         }
19042         return patch_alc882(codec);
19043 }
19044
19045 /*
19046  * ALC680 support
19047  */
19048 #define ALC680_DIGIN_NID        ALC880_DIGIN_NID
19049 #define ALC680_DIGOUT_NID       ALC880_DIGOUT_NID
19050 #define alc680_modes            alc260_modes
19051
19052 static hda_nid_t alc680_dac_nids[3] = {
19053         /* Lout1, Lout2, hp */
19054         0x02, 0x03, 0x04
19055 };
19056
19057 static hda_nid_t alc680_adc_nids[3] = {
19058         /* ADC0-2 */
19059         /* DMIC, MIC, Line-in*/
19060         0x07, 0x08, 0x09
19061 };
19062
19063 /*
19064  * Analog capture ADC cgange
19065  */
19066 static void alc680_rec_autoswitch(struct hda_codec *codec)
19067 {
19068         struct alc_spec *spec = codec->spec;
19069         struct auto_pin_cfg *cfg = &spec->autocfg;
19070         int pin_found = 0;
19071         int type_found = AUTO_PIN_LAST;
19072         hda_nid_t nid;
19073         int i;
19074
19075         for (i = 0; i < cfg->num_inputs; i++) {
19076                 nid = cfg->inputs[i].pin;
19077                 if (!(snd_hda_query_pin_caps(codec, nid) &
19078                       AC_PINCAP_PRES_DETECT))
19079                         continue;
19080                 if (snd_hda_jack_detect(codec, nid)) {
19081                         if (cfg->inputs[i].type < type_found) {
19082                                 type_found = cfg->inputs[i].type;
19083                                 pin_found = nid;
19084                         }
19085                 }
19086         }
19087
19088         nid = 0x07;
19089         if (pin_found)
19090                 snd_hda_get_connections(codec, pin_found, &nid, 1);
19091
19092         if (nid != spec->cur_adc)
19093                 __snd_hda_codec_cleanup_stream(codec, spec->cur_adc, 1);
19094         spec->cur_adc = nid;
19095         snd_hda_codec_setup_stream(codec, nid, spec->cur_adc_stream_tag, 0,
19096                                    spec->cur_adc_format);
19097 }
19098
19099 static int alc680_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
19100                                       struct hda_codec *codec,
19101                                       unsigned int stream_tag,
19102                                       unsigned int format,
19103                                       struct snd_pcm_substream *substream)
19104 {
19105         struct alc_spec *spec = codec->spec;
19106
19107         spec->cur_adc = 0x07;
19108         spec->cur_adc_stream_tag = stream_tag;
19109         spec->cur_adc_format = format;
19110
19111         alc680_rec_autoswitch(codec);
19112         return 0;
19113 }
19114
19115 static int alc680_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
19116                                       struct hda_codec *codec,
19117                                       struct snd_pcm_substream *substream)
19118 {
19119         snd_hda_codec_cleanup_stream(codec, 0x07);
19120         snd_hda_codec_cleanup_stream(codec, 0x08);
19121         snd_hda_codec_cleanup_stream(codec, 0x09);
19122         return 0;
19123 }
19124
19125 static struct hda_pcm_stream alc680_pcm_analog_auto_capture = {
19126         .substreams = 1, /* can be overridden */
19127         .channels_min = 2,
19128         .channels_max = 2,
19129         /* NID is set in alc_build_pcms */
19130         .ops = {
19131                 .prepare = alc680_capture_pcm_prepare,
19132                 .cleanup = alc680_capture_pcm_cleanup
19133         },
19134 };
19135
19136 static struct snd_kcontrol_new alc680_base_mixer[] = {
19137         /* output mixer control */
19138         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
19139         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
19140         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x4, 0x0, HDA_OUTPUT),
19141         HDA_CODEC_MUTE("Headphone Playback Switch", 0x16, 0x0, HDA_OUTPUT),
19142         HDA_CODEC_VOLUME("Int Mic Boost", 0x12, 0, HDA_INPUT),
19143         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
19144         HDA_CODEC_VOLUME("Line In Boost", 0x19, 0, HDA_INPUT),
19145         { }
19146 };
19147
19148 static struct hda_bind_ctls alc680_bind_cap_vol = {
19149         .ops = &snd_hda_bind_vol,
19150         .values = {
19151                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19152                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19153                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19154                 0
19155         },
19156 };
19157
19158 static struct hda_bind_ctls alc680_bind_cap_switch = {
19159         .ops = &snd_hda_bind_sw,
19160         .values = {
19161                 HDA_COMPOSE_AMP_VAL(0x07, 3, 0, HDA_INPUT),
19162                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
19163                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
19164                 0
19165         },
19166 };
19167
19168 static struct snd_kcontrol_new alc680_master_capture_mixer[] = {
19169         HDA_BIND_VOL("Capture Volume", &alc680_bind_cap_vol),
19170         HDA_BIND_SW("Capture Switch", &alc680_bind_cap_switch),
19171         { } /* end */
19172 };
19173
19174 /*
19175  * generic initialization of ADC, input mixers and output mixers
19176  */
19177 static struct hda_verb alc680_init_verbs[] = {
19178         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19179         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19180         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
19181
19182         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19183         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19184         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
19185         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
19186         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
19187         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
19188
19189         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19190         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19191         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19192         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19193         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
19194
19195         {0x16, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT   | AC_USRSP_EN},
19196         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19197         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT  | AC_USRSP_EN},
19198
19199         { }
19200 };
19201
19202 /* toggle speaker-output according to the hp-jack state */
19203 static void alc680_base_setup(struct hda_codec *codec)
19204 {
19205         struct alc_spec *spec = codec->spec;
19206
19207         spec->autocfg.hp_pins[0] = 0x16;
19208         spec->autocfg.speaker_pins[0] = 0x14;
19209         spec->autocfg.speaker_pins[1] = 0x15;
19210         spec->autocfg.num_inputs = 2;
19211         spec->autocfg.inputs[0].pin = 0x18;
19212         spec->autocfg.inputs[0].type = AUTO_PIN_MIC;
19213         spec->autocfg.inputs[1].pin = 0x19;
19214         spec->autocfg.inputs[1].type = AUTO_PIN_LINE;
19215 }
19216
19217 static void alc680_unsol_event(struct hda_codec *codec,
19218                                            unsigned int res)
19219 {
19220         if ((res >> 26) == ALC880_HP_EVENT)
19221                 alc_automute_amp(codec);
19222         if ((res >> 26) == ALC880_MIC_EVENT)
19223                 alc680_rec_autoswitch(codec);
19224 }
19225
19226 static void alc680_inithook(struct hda_codec *codec)
19227 {
19228         alc_automute_amp(codec);
19229         alc680_rec_autoswitch(codec);
19230 }
19231
19232 /* create input playback/capture controls for the given pin */
19233 static int alc680_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
19234                                     const char *ctlname, int idx)
19235 {
19236         hda_nid_t dac;
19237         int err;
19238
19239         switch (nid) {
19240         case 0x14:
19241                 dac = 0x02;
19242                 break;
19243         case 0x15:
19244                 dac = 0x03;
19245                 break;
19246         case 0x16:
19247                 dac = 0x04;
19248                 break;
19249         default:
19250                 return 0;
19251         }
19252         if (spec->multiout.dac_nids[0] != dac &&
19253             spec->multiout.dac_nids[1] != dac) {
19254                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
19255                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
19256                                                       HDA_OUTPUT));
19257                 if (err < 0)
19258                         return err;
19259
19260                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
19261                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
19262
19263                 if (err < 0)
19264                         return err;
19265                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
19266         }
19267
19268         return 0;
19269 }
19270
19271 /* add playback controls from the parsed DAC table */
19272 static int alc680_auto_create_multi_out_ctls(struct alc_spec *spec,
19273                                              const struct auto_pin_cfg *cfg)
19274 {
19275         hda_nid_t nid;
19276         int err;
19277
19278         spec->multiout.dac_nids = spec->private_dac_nids;
19279
19280         nid = cfg->line_out_pins[0];
19281         if (nid) {
19282                 const char *name;
19283                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
19284                         name = "Speaker";
19285                 else
19286                         name = "Front";
19287                 err = alc680_new_analog_output(spec, nid, name, 0);
19288                 if (err < 0)
19289                         return err;
19290         }
19291
19292         nid = cfg->speaker_pins[0];
19293         if (nid) {
19294                 err = alc680_new_analog_output(spec, nid, "Speaker", 0);
19295                 if (err < 0)
19296                         return err;
19297         }
19298         nid = cfg->hp_pins[0];
19299         if (nid) {
19300                 err = alc680_new_analog_output(spec, nid, "Headphone", 0);
19301                 if (err < 0)
19302                         return err;
19303         }
19304
19305         return 0;
19306 }
19307
19308 static void alc680_auto_set_output_and_unmute(struct hda_codec *codec,
19309                                               hda_nid_t nid, int pin_type)
19310 {
19311         alc_set_pin_output(codec, nid, pin_type);
19312 }
19313
19314 static void alc680_auto_init_multi_out(struct hda_codec *codec)
19315 {
19316         struct alc_spec *spec = codec->spec;
19317         hda_nid_t nid = spec->autocfg.line_out_pins[0];
19318         if (nid) {
19319                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
19320                 alc680_auto_set_output_and_unmute(codec, nid, pin_type);
19321         }
19322 }
19323
19324 static void alc680_auto_init_hp_out(struct hda_codec *codec)
19325 {
19326         struct alc_spec *spec = codec->spec;
19327         hda_nid_t pin;
19328
19329         pin = spec->autocfg.hp_pins[0];
19330         if (pin)
19331                 alc680_auto_set_output_and_unmute(codec, pin, PIN_HP);
19332         pin = spec->autocfg.speaker_pins[0];
19333         if (pin)
19334                 alc680_auto_set_output_and_unmute(codec, pin, PIN_OUT);
19335 }
19336
19337 /* pcm configuration: identical with ALC880 */
19338 #define alc680_pcm_analog_playback      alc880_pcm_analog_playback
19339 #define alc680_pcm_analog_capture       alc880_pcm_analog_capture
19340 #define alc680_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
19341 #define alc680_pcm_digital_playback     alc880_pcm_digital_playback
19342 #define alc680_pcm_digital_capture      alc880_pcm_digital_capture
19343
19344 /*
19345  * BIOS auto configuration
19346  */
19347 static int alc680_parse_auto_config(struct hda_codec *codec)
19348 {
19349         struct alc_spec *spec = codec->spec;
19350         int err;
19351         static hda_nid_t alc680_ignore[] = { 0 };
19352
19353         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
19354                                            alc680_ignore);
19355         if (err < 0)
19356                 return err;
19357
19358         if (!spec->autocfg.line_outs) {
19359                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
19360                         spec->multiout.max_channels = 2;
19361                         spec->no_analog = 1;
19362                         goto dig_only;
19363                 }
19364                 return 0; /* can't find valid BIOS pin config */
19365         }
19366         err = alc680_auto_create_multi_out_ctls(spec, &spec->autocfg);
19367         if (err < 0)
19368                 return err;
19369
19370         spec->multiout.max_channels = 2;
19371
19372  dig_only:
19373         /* digital only support output */
19374         alc_auto_parse_digital(codec);
19375         if (spec->kctls.list)
19376                 add_mixer(spec, spec->kctls.list);
19377
19378         add_verb(spec, alc680_init_verbs);
19379
19380         err = alc_auto_add_mic_boost(codec);
19381         if (err < 0)
19382                 return err;
19383
19384         return 1;
19385 }
19386
19387 #define alc680_auto_init_analog_input   alc882_auto_init_analog_input
19388
19389 /* init callback for auto-configuration model -- overriding the default init */
19390 static void alc680_auto_init(struct hda_codec *codec)
19391 {
19392         struct alc_spec *spec = codec->spec;
19393         alc680_auto_init_multi_out(codec);
19394         alc680_auto_init_hp_out(codec);
19395         alc680_auto_init_analog_input(codec);
19396         alc_auto_init_digital(codec);
19397         if (spec->unsol_event)
19398                 alc_inithook(codec);
19399 }
19400
19401 /*
19402  * configuration and preset
19403  */
19404 static const char *alc680_models[ALC680_MODEL_LAST] = {
19405         [ALC680_BASE]           = "base",
19406         [ALC680_AUTO]           = "auto",
19407 };
19408
19409 static struct snd_pci_quirk alc680_cfg_tbl[] = {
19410         SND_PCI_QUIRK(0x1043, 0x12f3, "ASUS NX90", ALC680_BASE),
19411         {}
19412 };
19413
19414 static struct alc_config_preset alc680_presets[] = {
19415         [ALC680_BASE] = {
19416                 .mixers = { alc680_base_mixer },
19417                 .cap_mixer =  alc680_master_capture_mixer,
19418                 .init_verbs = { alc680_init_verbs },
19419                 .num_dacs = ARRAY_SIZE(alc680_dac_nids),
19420                 .dac_nids = alc680_dac_nids,
19421                 .dig_out_nid = ALC680_DIGOUT_NID,
19422                 .num_channel_mode = ARRAY_SIZE(alc680_modes),
19423                 .channel_mode = alc680_modes,
19424                 .unsol_event = alc680_unsol_event,
19425                 .setup = alc680_base_setup,
19426                 .init_hook = alc680_inithook,
19427
19428         },
19429 };
19430
19431 static int patch_alc680(struct hda_codec *codec)
19432 {
19433         struct alc_spec *spec;
19434         int board_config;
19435         int err;
19436
19437         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
19438         if (spec == NULL)
19439                 return -ENOMEM;
19440
19441         codec->spec = spec;
19442
19443         board_config = snd_hda_check_board_config(codec, ALC680_MODEL_LAST,
19444                                                   alc680_models,
19445                                                   alc680_cfg_tbl);
19446
19447         if (board_config < 0 || board_config >= ALC680_MODEL_LAST) {
19448                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
19449                        codec->chip_name);
19450                 board_config = ALC680_AUTO;
19451         }
19452
19453         if (board_config == ALC680_AUTO) {
19454                 /* automatic parse from the BIOS config */
19455                 err = alc680_parse_auto_config(codec);
19456                 if (err < 0) {
19457                         alc_free(codec);
19458                         return err;
19459                 } else if (!err) {
19460                         printk(KERN_INFO
19461                                "hda_codec: Cannot set up configuration "
19462                                "from BIOS.  Using base mode...\n");
19463                         board_config = ALC680_BASE;
19464                 }
19465         }
19466
19467         if (board_config != ALC680_AUTO)
19468                 setup_preset(codec, &alc680_presets[board_config]);
19469
19470         spec->stream_analog_playback = &alc680_pcm_analog_playback;
19471         spec->stream_analog_capture = &alc680_pcm_analog_auto_capture;
19472         spec->stream_digital_playback = &alc680_pcm_digital_playback;
19473         spec->stream_digital_capture = &alc680_pcm_digital_capture;
19474
19475         if (!spec->adc_nids) {
19476                 spec->adc_nids = alc680_adc_nids;
19477                 spec->num_adc_nids = ARRAY_SIZE(alc680_adc_nids);
19478         }
19479
19480         if (!spec->cap_mixer)
19481                 set_capture_mixer(codec);
19482
19483         spec->vmaster_nid = 0x02;
19484
19485         codec->patch_ops = alc_patch_ops;
19486         if (board_config == ALC680_AUTO)
19487                 spec->init_hook = alc680_auto_init;
19488
19489         return 0;
19490 }
19491
19492 /*
19493  * patch entries
19494  */
19495 static struct hda_codec_preset snd_hda_preset_realtek[] = {
19496         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
19497         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
19498         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
19499         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
19500         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
19501         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
19502         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
19503         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
19504         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
19505           .patch = patch_alc861 },
19506         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
19507         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
19508         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
19509         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
19510           .patch = patch_alc882 },
19511         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
19512           .patch = patch_alc662 },
19513         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
19514         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
19515         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
19516         { .id = 0x10ec0680, .name = "ALC680", .patch = patch_alc680 },
19517         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
19518         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
19519         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
19520         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
19521           .patch = patch_alc882 },
19522         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
19523           .patch = patch_alc882 },
19524         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
19525         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
19526         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
19527           .patch = patch_alc882 },
19528         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
19529         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
19530         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
19531         {} /* terminator */
19532 };
19533
19534 MODULE_ALIAS("snd-hda-codec-id:10ec*");
19535
19536 MODULE_LICENSE("GPL");
19537 MODULE_DESCRIPTION("Realtek HD-audio codec");
19538
19539 static struct hda_codec_preset_list realtek_list = {
19540         .preset = snd_hda_preset_realtek,
19541         .owner = THIS_MODULE,
19542 };
19543
19544 static int __init patch_realtek_init(void)
19545 {
19546         return snd_hda_add_codec_preset(&realtek_list);
19547 }
19548
19549 static void __exit patch_realtek_exit(void)
19550 {
19551         snd_hda_delete_codec_preset(&realtek_list);
19552 }
19553
19554 module_init(patch_realtek_init)
19555 module_exit(patch_realtek_exit)