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

   1 /*
   2  * Universal Interface for Intel High Definition Audio Codec
   3  *
   4  * HD audio interface patch for ALC 260/880/882 codecs
   5  *
   6  * Copyright (c) 2004 Kailang Yang <kailang@realtek.com.tw>
   7  *                    PeiSen Hou <pshou@realtek.com.tw>
   8  *                    Takashi Iwai <tiwai@suse.de>
   9  *                    Jonathan Woithe <jwoithe@physics.adelaide.edu.au>
  10  *
  11  *  This driver is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This driver is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  24  */
  25
  26 #include <linux/init.h>
  27 #include <linux/delay.h>
  28 #include <linux/slab.h>
  29 #include <linux/pci.h>
  30 #include <sound/core.h>
  31 #include "hda_codec.h"
  32 #include "hda_local.h"
  33 #include "hda_beep.h"
  34
  35 #define ALC880_FRONT_EVENT              0x01
  36 #define ALC880_DCVOL_EVENT              0x02
  37 #define ALC880_HP_EVENT                 0x04
  38 #define ALC880_MIC_EVENT                0x08
  39
  40 /* ALC880 board config type */
  41 enum {
  42         ALC880_3ST,
  43         ALC880_3ST_DIG,
  44         ALC880_5ST,
  45         ALC880_5ST_DIG,
  46         ALC880_W810,
  47         ALC880_Z71V,
  48         ALC880_6ST,
  49         ALC880_6ST_DIG,
  50         ALC880_F1734,
  51         ALC880_ASUS,
  52         ALC880_ASUS_DIG,
  53         ALC880_ASUS_W1V,
  54         ALC880_ASUS_DIG2,
  55         ALC880_FUJITSU,
  56         ALC880_UNIWILL_DIG,
  57         ALC880_UNIWILL,
  58         ALC880_UNIWILL_P53,
  59         ALC880_CLEVO,
  60         ALC880_TCL_S700,
  61         ALC880_LG,
  62         ALC880_LG_LW,
  63         ALC880_MEDION_RIM,
  64 #ifdef CONFIG_SND_DEBUG
  65         ALC880_TEST,
  66 #endif
  67         ALC880_AUTO,
  68         ALC880_MODEL_LAST /* last tag */
  69 };
  70
  71 /* ALC260 models */
  72 enum {
  73         ALC260_BASIC,
  74         ALC260_HP,
  75         ALC260_HP_DC7600,
  76         ALC260_HP_3013,
  77         ALC260_FUJITSU_S702X,
  78         ALC260_ACER,
  79         ALC260_WILL,
  80         ALC260_REPLACER_672V,
  81         ALC260_FAVORIT100,
  82 #ifdef CONFIG_SND_DEBUG
  83         ALC260_TEST,
  84 #endif
  85         ALC260_AUTO,
  86         ALC260_MODEL_LAST /* last tag */
  87 };
  88
  89 /* ALC262 models */
  90 enum {
  91         ALC262_BASIC,
  92         ALC262_HIPPO,
  93         ALC262_HIPPO_1,
  94         ALC262_FUJITSU,
  95         ALC262_HP_BPC,
  96         ALC262_HP_BPC_D7000_WL,
  97         ALC262_HP_BPC_D7000_WF,
  98         ALC262_HP_TC_T5735,
  99         ALC262_HP_RP5700,
 100         ALC262_BENQ_ED8,
 101         ALC262_SONY_ASSAMD,
 102         ALC262_BENQ_T31,
 103         ALC262_ULTRA,
 104         ALC262_LENOVO_3000,
 105         ALC262_NEC,
 106         ALC262_TOSHIBA_S06,
 107         ALC262_TOSHIBA_RX1,
 108         ALC262_TYAN,
 109         ALC262_AUTO,
 110         ALC262_MODEL_LAST /* last tag */
 111 };
 112
 113 /* ALC268 models */
 114 enum {
 115         ALC267_QUANTA_IL1,
 116         ALC268_3ST,
 117         ALC268_TOSHIBA,
 118         ALC268_ACER,
 119         ALC268_ACER_DMIC,
 120         ALC268_ACER_ASPIRE_ONE,
 121         ALC268_DELL,
 122         ALC268_ZEPTO,
 123 #ifdef CONFIG_SND_DEBUG
 124         ALC268_TEST,
 125 #endif
 126         ALC268_AUTO,
 127         ALC268_MODEL_LAST /* last tag */
 128 };
 129
 130 /* ALC269 models */
 131 enum {
 132         ALC269_BASIC,
 133         ALC269_QUANTA_FL1,
 134         ALC269_ASUS_EEEPC_P703,
 135         ALC269_ASUS_EEEPC_P901,
 136         ALC269_FUJITSU,
 137         ALC269_LIFEBOOK,
 138         ALC269_AUTO,
 139         ALC269_MODEL_LAST /* last tag */
 140 };
 141
 142 /* ALC861 models */
 143 enum {
 144         ALC861_3ST,
 145         ALC660_3ST,
 146         ALC861_3ST_DIG,
 147         ALC861_6ST_DIG,
 148         ALC861_UNIWILL_M31,
 149         ALC861_TOSHIBA,
 150         ALC861_ASUS,
 151         ALC861_ASUS_LAPTOP,
 152         ALC861_AUTO,
 153         ALC861_MODEL_LAST,
 154 };
 155
 156 /* ALC861-VD models */
 157 enum {
 158         ALC660VD_3ST,
 159         ALC660VD_3ST_DIG,
 160         ALC660VD_ASUS_V1S,
 161         ALC861VD_3ST,
 162         ALC861VD_3ST_DIG,
 163         ALC861VD_6ST_DIG,
 164         ALC861VD_LENOVO,
 165         ALC861VD_DALLAS,
 166         ALC861VD_HP,
 167         ALC861VD_AUTO,
 168         ALC861VD_MODEL_LAST,
 169 };
 170
 171 /* ALC662 models */
 172 enum {
 173         ALC662_3ST_2ch_DIG,
 174         ALC662_3ST_6ch_DIG,
 175         ALC662_3ST_6ch,
 176         ALC662_5ST_DIG,
 177         ALC662_LENOVO_101E,
 178         ALC662_ASUS_EEEPC_P701,
 179         ALC662_ASUS_EEEPC_EP20,
 180         ALC663_ASUS_M51VA,
 181         ALC663_ASUS_G71V,
 182         ALC663_ASUS_H13,
 183         ALC663_ASUS_G50V,
 184         ALC662_ECS,
 185         ALC663_ASUS_MODE1,
 186         ALC662_ASUS_MODE2,
 187         ALC663_ASUS_MODE3,
 188         ALC663_ASUS_MODE4,
 189         ALC663_ASUS_MODE5,
 190         ALC663_ASUS_MODE6,
 191         ALC272_DELL,
 192         ALC272_DELL_ZM1,
 193         ALC272_SAMSUNG_NC10,
 194         ALC662_AUTO,
 195         ALC662_MODEL_LAST,
 196 };
 197
 198 /* ALC882 models */
 199 enum {
 200         ALC882_3ST_DIG,
 201         ALC882_6ST_DIG,
 202         ALC882_ARIMA,
 203         ALC882_W2JC,
 204         ALC882_TARGA,
 205         ALC882_ASUS_A7J,
 206         ALC882_ASUS_A7M,
 207         ALC885_MACPRO,
 208         ALC885_MBP3,
 209         ALC885_MB5,
 210         ALC885_IMAC24,
 211         ALC885_IMAC91,
 212         ALC883_3ST_2ch_DIG,
 213         ALC883_3ST_6ch_DIG,
 214         ALC883_3ST_6ch,
 215         ALC883_6ST_DIG,
 216         ALC883_TARGA_DIG,
 217         ALC883_TARGA_2ch_DIG,
 218         ALC883_TARGA_8ch_DIG,
 219         ALC883_ACER,
 220         ALC883_ACER_ASPIRE,
 221         ALC888_ACER_ASPIRE_4930G,
 222         ALC888_ACER_ASPIRE_6530G,
 223         ALC888_ACER_ASPIRE_8930G,
 224         ALC888_ACER_ASPIRE_7730G,
 225         ALC883_MEDION,
 226         ALC883_MEDION_MD2,
 227         ALC883_LAPTOP_EAPD,
 228         ALC883_LENOVO_101E_2ch,
 229         ALC883_LENOVO_NB0763,
 230         ALC888_LENOVO_MS7195_DIG,
 231         ALC888_LENOVO_SKY,
 232         ALC883_HAIER_W66,
 233         ALC888_3ST_HP,
 234         ALC888_6ST_DELL,
 235         ALC883_MITAC,
 236         ALC883_CLEVO_M540R,
 237         ALC883_CLEVO_M720,
 238         ALC883_FUJITSU_PI2515,
 239         ALC888_FUJITSU_XA3530,
 240         ALC883_3ST_6ch_INTEL,
 241         ALC889A_INTEL,
 242         ALC889_INTEL,
 243         ALC888_ASUS_M90V,
 244         ALC888_ASUS_EEE1601,
 245         ALC889A_MB31,
 246         ALC1200_ASUS_P5Q,
 247         ALC883_SONY_VAIO_TT,
 248         ALC882_AUTO,
 249         ALC882_MODEL_LAST,
 250 };
 251
 252 /* for GPIO Poll */
 253 #define GPIO_MASK       0x03
 254
 255 /* extra amp-initialization sequence types */
 256 enum {
 257         ALC_INIT_NONE,
 258         ALC_INIT_DEFAULT,
 259         ALC_INIT_GPIO1,
 260         ALC_INIT_GPIO2,
 261         ALC_INIT_GPIO3,
 262 };
 263
 264 struct alc_mic_route {
 265         hda_nid_t pin;
 266         unsigned char mux_idx;
 267         unsigned char amix_idx;
 268 };
 269
 270 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 271
 272 struct alc_spec {
 273         /* codec parameterization */
 274         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 275         unsigned int num_mixers;
 276         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 277         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 278
 279         const struct hda_verb *init_verbs[10];  /* initialization verbs
 280                                                  * don't forget NULL
 281                                                  * termination!
 282                                                  */
 283         unsigned int num_init_verbs;
 284
 285         char stream_name_analog[32];    /* analog PCM stream */
 286         struct hda_pcm_stream *stream_analog_playback;
 287         struct hda_pcm_stream *stream_analog_capture;
 288         struct hda_pcm_stream *stream_analog_alt_playback;
 289         struct hda_pcm_stream *stream_analog_alt_capture;
 290
 291         char stream_name_digital[32];   /* digital PCM stream */
 292         struct hda_pcm_stream *stream_digital_playback;
 293         struct hda_pcm_stream *stream_digital_capture;
 294
 295         /* playback */
 296         struct hda_multi_out multiout;  /* playback set-up
 297                                          * max_channels, dacs must be set
 298                                          * dig_out_nid and hp_nid are optional
 299                                          */
 300         hda_nid_t alt_dac_nid;
 301         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 302         int dig_out_type;
 303
 304         /* capture */
 305         unsigned int num_adc_nids;
 306         hda_nid_t *adc_nids;
 307         hda_nid_t *capsrc_nids;
 308         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 309
 310         /* capture source */
 311         unsigned int num_mux_defs;
 312         const struct hda_input_mux *input_mux;
 313         unsigned int cur_mux[3];
 314         struct alc_mic_route ext_mic;
 315         struct alc_mic_route int_mic;
 316
 317         /* channel model */
 318         const struct hda_channel_mode *channel_mode;
 319         int num_channel_mode;
 320         int need_dac_fix;
 321         int const_channel_count;
 322         int ext_channel_count;
 323
 324         /* PCM information */
 325         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 326
 327         /* dynamic controls, init_verbs and input_mux */
 328         struct auto_pin_cfg autocfg;
 329         struct snd_array kctls;
 330         struct hda_input_mux private_imux[3];
 331         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 332         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 333         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 334
 335         /* hooks */
 336         void (*init_hook)(struct hda_codec *codec);
 337         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 338
 339         /* for pin sensing */
 340         unsigned int sense_updated: 1;
 341         unsigned int jack_present: 1;
 342         unsigned int master_sw: 1;
 343         unsigned int auto_mic:1;
 344
 345         /* other flags */
 346         unsigned int no_analog :1; /* digital I/O only */
 347         int init_amp;
 348
 349         /* for virtual master */
 350         hda_nid_t vmaster_nid;
 351 #ifdef CONFIG_SND_HDA_POWER_SAVE
 352         struct hda_loopback_check loopback;
 353 #endif
 354
 355         /* for PLL fix */
 356         hda_nid_t pll_nid;
 357         unsigned int pll_coef_idx, pll_coef_bit;
 358 };
 359
 360 /*
 361  * configuration template - to be copied to the spec instance
 362  */
 363 struct alc_config_preset {
 364         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 365                                              * with spec
 366                                              */
 367         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 368         const struct hda_verb *init_verbs[5];
 369         unsigned int num_dacs;
 370         hda_nid_t *dac_nids;
 371         hda_nid_t dig_out_nid;          /* optional */
 372         hda_nid_t hp_nid;               /* optional */
 373         hda_nid_t *slave_dig_outs;
 374         unsigned int num_adc_nids;
 375         hda_nid_t *adc_nids;
 376         hda_nid_t *capsrc_nids;
 377         hda_nid_t dig_in_nid;
 378         unsigned int num_channel_mode;
 379         const struct hda_channel_mode *channel_mode;
 380         int need_dac_fix;
 381         int const_channel_count;
 382         unsigned int num_mux_defs;
 383         const struct hda_input_mux *input_mux;
 384         void (*unsol_event)(struct hda_codec *, unsigned int);
 385         void (*setup)(struct hda_codec *);
 386         void (*init_hook)(struct hda_codec *);
 387 #ifdef CONFIG_SND_HDA_POWER_SAVE
 388         struct hda_amp_list *loopbacks;
 389 #endif
 390 };
 391
 392
 393 /*
 394  * input MUX handling
 395  */
 396 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 397                              struct snd_ctl_elem_info *uinfo)
 398 {
 399         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 400         struct alc_spec *spec = codec->spec;
 401         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 402         if (mux_idx >= spec->num_mux_defs)
 403                 mux_idx = 0;
 404         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 405 }
 406
 407 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 408                             struct snd_ctl_elem_value *ucontrol)
 409 {
 410         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 411         struct alc_spec *spec = codec->spec;
 412         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 413
 414         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 415         return 0;
 416 }
 417
 418 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 419                             struct snd_ctl_elem_value *ucontrol)
 420 {
 421         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 422         struct alc_spec *spec = codec->spec;
 423         const struct hda_input_mux *imux;
 424         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 425         unsigned int mux_idx;
 426         hda_nid_t nid = spec->capsrc_nids ?
 427                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 428         unsigned int type;
 429
 430         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 431         imux = &spec->input_mux[mux_idx];
 432
 433         type = get_wcaps_type(get_wcaps(codec, nid));
 434         if (type == AC_WID_AUD_MIX) {
 435                 /* Matrix-mixer style (e.g. ALC882) */
 436                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 437                 unsigned int i, idx;
 438
 439                 idx = ucontrol->value.enumerated.item[0];
 440                 if (idx >= imux->num_items)
 441                         idx = imux->num_items - 1;
 442                 if (*cur_val == idx)
 443                         return 0;
 444                 for (i = 0; i < imux->num_items; i++) {
 445                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 446                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 447                                                  imux->items[i].index,
 448                                                  HDA_AMP_MUTE, v);
 449                 }
 450                 *cur_val = idx;
 451                 return 1;
 452         } else {
 453                 /* MUX style (e.g. ALC880) */
 454                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 455                                              &spec->cur_mux[adc_idx]);
 456         }
 457 }
 458
 459 /*
 460  * channel mode setting
 461  */
 462 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 463                             struct snd_ctl_elem_info *uinfo)
 464 {
 465         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 466         struct alc_spec *spec = codec->spec;
 467         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 468                                     spec->num_channel_mode);
 469 }
 470
 471 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 472                            struct snd_ctl_elem_value *ucontrol)
 473 {
 474         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 475         struct alc_spec *spec = codec->spec;
 476         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 477                                    spec->num_channel_mode,
 478                                    spec->ext_channel_count);
 479 }
 480
 481 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 482                            struct snd_ctl_elem_value *ucontrol)
 483 {
 484         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 485         struct alc_spec *spec = codec->spec;
 486         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 487                                       spec->num_channel_mode,
 488                                       &spec->ext_channel_count);
 489         if (err >= 0 && !spec->const_channel_count) {
 490                 spec->multiout.max_channels = spec->ext_channel_count;
 491                 if (spec->need_dac_fix)
 492                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 493         }
 494         return err;
 495 }
 496
 497 /*
 498  * Control the mode of pin widget settings via the mixer.  "pc" is used
 499  * instead of "%" to avoid consequences of accidently treating the % as
 500  * being part of a format specifier.  Maximum allowed length of a value is
 501  * 63 characters plus NULL terminator.
 502  *
 503  * Note: some retasking pin complexes seem to ignore requests for input
 504  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 505  * are requested.  Therefore order this list so that this behaviour will not
 506  * cause problems when mixer clients move through the enum sequentially.
 507  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 508  * March 2006.
 509  */
 510 static char *alc_pin_mode_names[] = {
 511         "Mic 50pc bias", "Mic 80pc bias",
 512         "Line in", "Line out", "Headphone out",
 513 };
 514 static unsigned char alc_pin_mode_values[] = {
 515         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 516 };
 517 /* The control can present all 5 options, or it can limit the options based
 518  * in the pin being assumed to be exclusively an input or an output pin.  In
 519  * addition, "input" pins may or may not process the mic bias option
 520  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 521  * accept requests for bias as of chip versions up to March 2006) and/or
 522  * wiring in the computer.
 523  */
 524 #define ALC_PIN_DIR_IN              0x00
 525 #define ALC_PIN_DIR_OUT             0x01
 526 #define ALC_PIN_DIR_INOUT           0x02
 527 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 528 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 529
 530 /* Info about the pin modes supported by the different pin direction modes.
 531  * For each direction the minimum and maximum values are given.
 532  */
 533 static signed char alc_pin_mode_dir_info[5][2] = {
 534         { 0, 2 },    /* ALC_PIN_DIR_IN */
 535         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 536         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 537         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 538         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 539 };
 540 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 541 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 542 #define alc_pin_mode_n_items(_dir) \
 543         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 544
 545 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 546                              struct snd_ctl_elem_info *uinfo)
 547 {
 548         unsigned int item_num = uinfo->value.enumerated.item;
 549         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 550
 551         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 552         uinfo->count = 1;
 553         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 554
 555         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 556                 item_num = alc_pin_mode_min(dir);
 557         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 558         return 0;
 559 }
 560
 561 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 562                             struct snd_ctl_elem_value *ucontrol)
 563 {
 564         unsigned int i;
 565         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 566         hda_nid_t nid = kcontrol->private_value & 0xffff;
 567         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 568         long *valp = ucontrol->value.integer.value;
 569         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 570                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 571                                                  0x00);
 572
 573         /* Find enumerated value for current pinctl setting */
 574         i = alc_pin_mode_min(dir);
 575         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 576                 i++;
 577         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 578         return 0;
 579 }
 580
 581 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 582                             struct snd_ctl_elem_value *ucontrol)
 583 {
 584         signed int change;
 585         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 586         hda_nid_t nid = kcontrol->private_value & 0xffff;
 587         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 588         long val = *ucontrol->value.integer.value;
 589         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 590                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 591                                                  0x00);
 592
 593         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 594                 val = alc_pin_mode_min(dir);
 595
 596         change = pinctl != alc_pin_mode_values[val];
 597         if (change) {
 598                 /* Set pin mode to that requested */
 599                 snd_hda_codec_write_cache(codec, nid, 0,
 600                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 601                                           alc_pin_mode_values[val]);
 602
 603                 /* Also enable the retasking pin's input/output as required
 604                  * for the requested pin mode.  Enum values of 2 or less are
 605                  * input modes.
 606                  *
 607                  * Dynamically switching the input/output buffers probably
 608                  * reduces noise slightly (particularly on input) so we'll
 609                  * do it.  However, having both input and output buffers
 610                  * enabled simultaneously doesn't seem to be problematic if
 611                  * this turns out to be necessary in the future.
 612                  */
 613                 if (val <= 2) {
 614                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 615                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 616                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 617                                                  HDA_AMP_MUTE, 0);
 618                 } else {
 619                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 620                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 621                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 622                                                  HDA_AMP_MUTE, 0);
 623                 }
 624         }
 625         return change;
 626 }
 627
 628 #define ALC_PIN_MODE(xname, nid, dir) \
 629         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 630           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 631           .info = alc_pin_mode_info, \
 632           .get = alc_pin_mode_get, \
 633           .put = alc_pin_mode_put, \
 634           .private_value = nid | (dir<<16) }
 635
 636 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 637  * together using a mask with more than one bit set.  This control is
 638  * currently used only by the ALC260 test model.  At this stage they are not
 639  * needed for any "production" models.
 640  */
 641 #ifdef CONFIG_SND_DEBUG
 642 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 643
 644 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 645                              struct snd_ctl_elem_value *ucontrol)
 646 {
 647         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 648         hda_nid_t nid = kcontrol->private_value & 0xffff;
 649         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 650         long *valp = ucontrol->value.integer.value;
 651         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 652                                               AC_VERB_GET_GPIO_DATA, 0x00);
 653
 654         *valp = (val & mask) != 0;
 655         return 0;
 656 }
 657 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 658                              struct snd_ctl_elem_value *ucontrol)
 659 {
 660         signed int change;
 661         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 662         hda_nid_t nid = kcontrol->private_value & 0xffff;
 663         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 664         long val = *ucontrol->value.integer.value;
 665         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 666                                                     AC_VERB_GET_GPIO_DATA,
 667                                                     0x00);
 668
 669         /* Set/unset the masked GPIO bit(s) as needed */
 670         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 671         if (val == 0)
 672                 gpio_data &= ~mask;
 673         else
 674                 gpio_data |= mask;
 675         snd_hda_codec_write_cache(codec, nid, 0,
 676                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 677
 678         return change;
 679 }
 680 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 681         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 682           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 683           .info = alc_gpio_data_info, \
 684           .get = alc_gpio_data_get, \
 685           .put = alc_gpio_data_put, \
 686           .private_value = nid | (mask<<16) }
 687 #endif   /* CONFIG_SND_DEBUG */
 688
 689 /* A switch control to allow the enabling of the digital IO pins on the
 690  * ALC260.  This is incredibly simplistic; the intention of this control is
 691  * to provide something in the test model allowing digital outputs to be
 692  * identified if present.  If models are found which can utilise these
 693  * outputs a more complete mixer control can be devised for those models if
 694  * necessary.
 695  */
 696 #ifdef CONFIG_SND_DEBUG
 697 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 698
 699 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 700                               struct snd_ctl_elem_value *ucontrol)
 701 {
 702         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 703         hda_nid_t nid = kcontrol->private_value & 0xffff;
 704         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 705         long *valp = ucontrol->value.integer.value;
 706         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 707                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 708
 709         *valp = (val & mask) != 0;
 710         return 0;
 711 }
 712 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 713                               struct snd_ctl_elem_value *ucontrol)
 714 {
 715         signed int change;
 716         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 717         hda_nid_t nid = kcontrol->private_value & 0xffff;
 718         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 719         long val = *ucontrol->value.integer.value;
 720         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 721                                                     AC_VERB_GET_DIGI_CONVERT_1,
 722                                                     0x00);
 723
 724         /* Set/unset the masked control bit(s) as needed */
 725         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 726         if (val==0)
 727                 ctrl_data &= ~mask;
 728         else
 729                 ctrl_data |= mask;
 730         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 731                                   ctrl_data);
 732
 733         return change;
 734 }
 735 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 736         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 737           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 738           .info = alc_spdif_ctrl_info, \
 739           .get = alc_spdif_ctrl_get, \
 740           .put = alc_spdif_ctrl_put, \
 741           .private_value = nid | (mask<<16) }
 742 #endif   /* CONFIG_SND_DEBUG */
 743
 744 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 745  * Again, this is only used in the ALC26x test models to help identify when
 746  * the EAPD line must be asserted for features to work.
 747  */
 748 #ifdef CONFIG_SND_DEBUG
 749 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 750
 751 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 752                               struct snd_ctl_elem_value *ucontrol)
 753 {
 754         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 755         hda_nid_t nid = kcontrol->private_value & 0xffff;
 756         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 757         long *valp = ucontrol->value.integer.value;
 758         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 759                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 760
 761         *valp = (val & mask) != 0;
 762         return 0;
 763 }
 764
 765 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 766                               struct snd_ctl_elem_value *ucontrol)
 767 {
 768         int change;
 769         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 770         hda_nid_t nid = kcontrol->private_value & 0xffff;
 771         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 772         long val = *ucontrol->value.integer.value;
 773         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 774                                                     AC_VERB_GET_EAPD_BTLENABLE,
 775                                                     0x00);
 776
 777         /* Set/unset the masked control bit(s) as needed */
 778         change = (!val ? 0 : mask) != (ctrl_data & mask);
 779         if (!val)
 780                 ctrl_data &= ~mask;
 781         else
 782                 ctrl_data |= mask;
 783         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 784                                   ctrl_data);
 785
 786         return change;
 787 }
 788
 789 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 790         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 791           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 792           .info = alc_eapd_ctrl_info, \
 793           .get = alc_eapd_ctrl_get, \
 794           .put = alc_eapd_ctrl_put, \
 795           .private_value = nid | (mask<<16) }
 796 #endif   /* CONFIG_SND_DEBUG */
 797
 798 /*
 799  * set up the input pin config (depending on the given auto-pin type)
 800  */
 801 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 802                               int auto_pin_type)
 803 {
 804         unsigned int val = PIN_IN;
 805
 806         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 807                 unsigned int pincap;
 808                 pincap = snd_hda_query_pin_caps(codec, nid);
 809                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 810                 if (pincap & AC_PINCAP_VREF_80)
 811                         val = PIN_VREF80;
 812                 else if (pincap & AC_PINCAP_VREF_50)
 813                         val = PIN_VREF50;
 814                 else if (pincap & AC_PINCAP_VREF_100)
 815                         val = PIN_VREF100;
 816                 else if (pincap & AC_PINCAP_VREF_GRD)
 817                         val = PIN_VREFGRD;
 818         }
 819         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 820 }
 821
 822 /*
 823  */
 824 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 825 {
 826         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 827                 return;
 828         spec->mixers[spec->num_mixers++] = mix;
 829 }
 830
 831 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 832 {
 833         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 834                 return;
 835         spec->init_verbs[spec->num_init_verbs++] = verb;
 836 }
 837
 838 #ifdef CONFIG_PROC_FS
 839 /*
 840  * hook for proc
 841  */
 842 static void print_realtek_coef(struct snd_info_buffer *buffer,
 843                                struct hda_codec *codec, hda_nid_t nid)
 844 {
 845         int coeff;
 846
 847         if (nid != 0x20)
 848                 return;
 849         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 850         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 851         coeff = snd_hda_codec_read(codec, nid, 0,
 852                                    AC_VERB_GET_COEF_INDEX, 0);
 853         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 854 }
 855 #else
 856 #define print_realtek_coef      NULL
 857 #endif
 858
 859 /*
 860  * set up from the preset table
 861  */
 862 static void setup_preset(struct hda_codec *codec,
 863                          const struct alc_config_preset *preset)
 864 {
 865         struct alc_spec *spec = codec->spec;
 866         int i;
 867
 868         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 869                 add_mixer(spec, preset->mixers[i]);
 870         spec->cap_mixer = preset->cap_mixer;
 871         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 872              i++)
 873                 add_verb(spec, preset->init_verbs[i]);
 874
 875         spec->channel_mode = preset->channel_mode;
 876         spec->num_channel_mode = preset->num_channel_mode;
 877         spec->need_dac_fix = preset->need_dac_fix;
 878         spec->const_channel_count = preset->const_channel_count;
 879
 880         if (preset->const_channel_count)
 881                 spec->multiout.max_channels = preset->const_channel_count;
 882         else
 883                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 884         spec->ext_channel_count = spec->channel_mode[0].channels;
 885
 886         spec->multiout.num_dacs = preset->num_dacs;
 887         spec->multiout.dac_nids = preset->dac_nids;
 888         spec->multiout.dig_out_nid = preset->dig_out_nid;
 889         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 890         spec->multiout.hp_nid = preset->hp_nid;
 891
 892         spec->num_mux_defs = preset->num_mux_defs;
 893         if (!spec->num_mux_defs)
 894                 spec->num_mux_defs = 1;
 895         spec->input_mux = preset->input_mux;
 896
 897         spec->num_adc_nids = preset->num_adc_nids;
 898         spec->adc_nids = preset->adc_nids;
 899         spec->capsrc_nids = preset->capsrc_nids;
 900         spec->dig_in_nid = preset->dig_in_nid;
 901
 902         spec->unsol_event = preset->unsol_event;
 903         spec->init_hook = preset->init_hook;
 904 #ifdef CONFIG_SND_HDA_POWER_SAVE
 905         spec->loopback.amplist = preset->loopbacks;
 906 #endif
 907
 908         if (preset->setup)
 909                 preset->setup(codec);
 910 }
 911
 912 /* Enable GPIO mask and set output */
 913 static struct hda_verb alc_gpio1_init_verbs[] = {
 914         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 915         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 916         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 917         { }
 918 };
 919
 920 static struct hda_verb alc_gpio2_init_verbs[] = {
 921         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 922         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 923         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 924         { }
 925 };
 926
 927 static struct hda_verb alc_gpio3_init_verbs[] = {
 928         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 929         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 930         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 931         { }
 932 };
 933
 934 /*
 935  * Fix hardware PLL issue
 936  * On some codecs, the analog PLL gating control must be off while
 937  * the default value is 1.
 938  */
 939 static void alc_fix_pll(struct hda_codec *codec)
 940 {
 941         struct alc_spec *spec = codec->spec;
 942         unsigned int val;
 943
 944         if (!spec->pll_nid)
 945                 return;
 946         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 947                             spec->pll_coef_idx);
 948         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 949                                  AC_VERB_GET_PROC_COEF, 0);
 950         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 951                             spec->pll_coef_idx);
 952         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 953                             val & ~(1 << spec->pll_coef_bit));
 954 }
 955
 956 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 957                              unsigned int coef_idx, unsigned int coef_bit)
 958 {
 959         struct alc_spec *spec = codec->spec;
 960         spec->pll_nid = nid;
 961         spec->pll_coef_idx = coef_idx;
 962         spec->pll_coef_bit = coef_bit;
 963         alc_fix_pll(codec);
 964 }
 965
 966 static void alc_automute_pin(struct hda_codec *codec)
 967 {
 968         struct alc_spec *spec = codec->spec;
 969         unsigned int nid = spec->autocfg.hp_pins[0];
 970         int i;
 971
 972         if (!nid)
 973                 return;
 974         spec->jack_present = snd_hda_jack_detect(codec, nid);
 975         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 976                 nid = spec->autocfg.speaker_pins[i];
 977                 if (!nid)
 978                         break;
 979                 snd_hda_codec_write(codec, nid, 0,
 980                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 981                                     spec->jack_present ? 0 : PIN_OUT);
 982         }
 983 }
 984
 985 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 986                                 hda_nid_t nid)
 987 {
 988         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 989         int i, nums;
 990
 991         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 992         for (i = 0; i < nums; i++)
 993                 if (conn[i] == nid)
 994                         return i;
 995         return -1;
 996 }
 997
 998 static void alc_mic_automute(struct hda_codec *codec)
 999 {
1000         struct alc_spec *spec = codec->spec;
1001         struct alc_mic_route *dead, *alive;
1002         unsigned int present, type;
1003         hda_nid_t cap_nid;
1004
1005         if (!spec->auto_mic)
1006                 return;
1007         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1008                 return;
1009         if (snd_BUG_ON(!spec->adc_nids))
1010                 return;
1011
1012         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1013
1014         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1015         if (present) {
1016                 alive = &spec->ext_mic;
1017                 dead = &spec->int_mic;
1018         } else {
1019                 alive = &spec->int_mic;
1020                 dead = &spec->ext_mic;
1021         }
1022
1023         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1024         if (type == AC_WID_AUD_MIX) {
1025                 /* Matrix-mixer style (e.g. ALC882) */
1026                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1027                                          alive->mux_idx,
1028                                          HDA_AMP_MUTE, 0);
1029                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1030                                          dead->mux_idx,
1031                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1032         } else {
1033                 /* MUX style (e.g. ALC880) */
1034                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1035                                           AC_VERB_SET_CONNECT_SEL,
1036                                           alive->mux_idx);
1037         }
1038
1039         /* FIXME: analog mixer */
1040 }
1041
1042 /* unsolicited event for HP jack sensing */
1043 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1044 {
1045         if (codec->vendor_id == 0x10ec0880)
1046                 res >>= 28;
1047         else
1048                 res >>= 26;
1049         switch (res) {
1050         case ALC880_HP_EVENT:
1051                 alc_automute_pin(codec);
1052                 break;
1053         case ALC880_MIC_EVENT:
1054                 alc_mic_automute(codec);
1055                 break;
1056         }
1057 }
1058
1059 static void alc_inithook(struct hda_codec *codec)
1060 {
1061         alc_automute_pin(codec);
1062         alc_mic_automute(codec);
1063 }
1064
1065 /* additional initialization for ALC888 variants */
1066 static void alc888_coef_init(struct hda_codec *codec)
1067 {
1068         unsigned int tmp;
1069
1070         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1071         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1072         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1073         if ((tmp & 0xf0) == 0x20)
1074                 /* alc888S-VC */
1075                 snd_hda_codec_read(codec, 0x20, 0,
1076                                    AC_VERB_SET_PROC_COEF, 0x830);
1077          else
1078                  /* alc888-VB */
1079                  snd_hda_codec_read(codec, 0x20, 0,
1080                                     AC_VERB_SET_PROC_COEF, 0x3030);
1081 }
1082
1083 static void alc889_coef_init(struct hda_codec *codec)
1084 {
1085         unsigned int tmp;
1086
1087         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1088         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1089         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1090         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1091 }
1092
1093 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1094 {
1095         unsigned int tmp;
1096
1097         switch (type) {
1098         case ALC_INIT_GPIO1:
1099                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1100                 break;
1101         case ALC_INIT_GPIO2:
1102                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1103                 break;
1104         case ALC_INIT_GPIO3:
1105                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1106                 break;
1107         case ALC_INIT_DEFAULT:
1108                 switch (codec->vendor_id) {
1109                 case 0x10ec0260:
1110                         snd_hda_codec_write(codec, 0x0f, 0,
1111                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1112                         snd_hda_codec_write(codec, 0x10, 0,
1113                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1114                         break;
1115                 case 0x10ec0262:
1116                 case 0x10ec0267:
1117                 case 0x10ec0268:
1118                 case 0x10ec0269:
1119                 case 0x10ec0272:
1120                 case 0x10ec0660:
1121                 case 0x10ec0662:
1122                 case 0x10ec0663:
1123                 case 0x10ec0862:
1124                 case 0x10ec0889:
1125                         snd_hda_codec_write(codec, 0x14, 0,
1126                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1127                         snd_hda_codec_write(codec, 0x15, 0,
1128                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1129                         break;
1130                 }
1131                 switch (codec->vendor_id) {
1132                 case 0x10ec0260:
1133                         snd_hda_codec_write(codec, 0x1a, 0,
1134                                             AC_VERB_SET_COEF_INDEX, 7);
1135                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1136                                                  AC_VERB_GET_PROC_COEF, 0);
1137                         snd_hda_codec_write(codec, 0x1a, 0,
1138                                             AC_VERB_SET_COEF_INDEX, 7);
1139                         snd_hda_codec_write(codec, 0x1a, 0,
1140                                             AC_VERB_SET_PROC_COEF,
1141                                             tmp | 0x2010);
1142                         break;
1143                 case 0x10ec0262:
1144                 case 0x10ec0880:
1145                 case 0x10ec0882:
1146                 case 0x10ec0883:
1147                 case 0x10ec0885:
1148                 case 0x10ec0887:
1149                 case 0x10ec0889:
1150                         alc889_coef_init(codec);
1151                         break;
1152                 case 0x10ec0888:
1153                         alc888_coef_init(codec);
1154                         break;
1155                 case 0x10ec0267:
1156                 case 0x10ec0268:
1157                         snd_hda_codec_write(codec, 0x20, 0,
1158                                             AC_VERB_SET_COEF_INDEX, 7);
1159                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1160                                                  AC_VERB_GET_PROC_COEF, 0);
1161                         snd_hda_codec_write(codec, 0x20, 0,
1162                                             AC_VERB_SET_COEF_INDEX, 7);
1163                         snd_hda_codec_write(codec, 0x20, 0,
1164                                             AC_VERB_SET_PROC_COEF,
1165                                             tmp | 0x3000);
1166                         break;
1167                 }
1168                 break;
1169         }
1170 }
1171
1172 static void alc_init_auto_hp(struct hda_codec *codec)
1173 {
1174         struct alc_spec *spec = codec->spec;
1175
1176         if (!spec->autocfg.hp_pins[0])
1177                 return;
1178
1179         if (!spec->autocfg.speaker_pins[0]) {
1180                 if (spec->autocfg.line_out_pins[0] &&
1181                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1182                         spec->autocfg.speaker_pins[0] =
1183                                 spec->autocfg.line_out_pins[0];
1184                 else
1185                         return;
1186         }
1187
1188         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1189                     spec->autocfg.hp_pins[0]);
1190         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1191                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1192                                   AC_USRSP_EN | ALC880_HP_EVENT);
1193         spec->unsol_event = alc_sku_unsol_event;
1194 }
1195
1196 static void alc_init_auto_mic(struct hda_codec *codec)
1197 {
1198         struct alc_spec *spec = codec->spec;
1199         struct auto_pin_cfg *cfg = &spec->autocfg;
1200         hda_nid_t fixed, ext;
1201         int i;
1202
1203         /* there must be only two mic inputs exclusively */
1204         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1205                 if (cfg->input_pins[i])
1206                         return;
1207
1208         fixed = ext = 0;
1209         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1210                 hda_nid_t nid = cfg->input_pins[i];
1211                 unsigned int defcfg;
1212                 if (!nid)
1213                         return;
1214                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1215                 switch (get_defcfg_connect(defcfg)) {
1216                 case AC_JACK_PORT_FIXED:
1217                         if (fixed)
1218                                 return; /* already occupied */
1219                         fixed = nid;
1220                         break;
1221                 case AC_JACK_PORT_COMPLEX:
1222                         if (ext)
1223                                 return; /* already occupied */
1224                         ext = nid;
1225                         break;
1226                 default:
1227                         return; /* invalid entry */
1228                 }
1229         }
1230         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1231                 return; /* no unsol support */
1232         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1233                     ext, fixed);
1234         spec->ext_mic.pin = ext;
1235         spec->int_mic.pin = fixed;
1236         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1237         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1238         spec->auto_mic = 1;
1239         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1240                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1241                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1242         spec->unsol_event = alc_sku_unsol_event;
1243 }
1244
1245 /* check subsystem ID and set up device-specific initialization;
1246  * return 1 if initialized, 0 if invalid SSID
1247  */
1248 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1249  *      31 ~ 16 :       Manufacture ID
1250  *      15 ~ 8  :       SKU ID
1251  *      7  ~ 0  :       Assembly ID
1252  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1253  */
1254 static int alc_subsystem_id(struct hda_codec *codec,
1255                             hda_nid_t porta, hda_nid_t porte,
1256                             hda_nid_t portd)
1257 {
1258         unsigned int ass, tmp, i;
1259         unsigned nid;
1260         struct alc_spec *spec = codec->spec;
1261
1262         ass = codec->subsystem_id & 0xffff;
1263         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1264                 goto do_sku;
1265
1266         /* invalid SSID, check the special NID pin defcfg instead */
1267         /*
1268          * 31~30        : port connectivity
1269          * 29~21        : reserve
1270          * 20           : PCBEEP input
1271          * 19~16        : Check sum (15:1)
1272          * 15~1         : Custom
1273          * 0            : override
1274         */
1275         nid = 0x1d;
1276         if (codec->vendor_id == 0x10ec0260)
1277                 nid = 0x17;
1278         ass = snd_hda_codec_get_pincfg(codec, nid);
1279         snd_printd("realtek: No valid SSID, "
1280                    "checking pincfg 0x%08x for NID 0x%x\n",
1281                    ass, nid);
1282         if (!(ass & 1) && !(ass & 0x100000))
1283                 return 0;
1284         if ((ass >> 30) != 1)   /* no physical connection */
1285                 return 0;
1286
1287         /* check sum */
1288         tmp = 0;
1289         for (i = 1; i < 16; i++) {
1290                 if ((ass >> i) & 1)
1291                         tmp++;
1292         }
1293         if (((ass >> 16) & 0xf) != tmp)
1294                 return 0;
1295 do_sku:
1296         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1297                    ass & 0xffff, codec->vendor_id);
1298         /*
1299          * 0 : override
1300          * 1 :  Swap Jack
1301          * 2 : 0 --> Desktop, 1 --> Laptop
1302          * 3~5 : External Amplifier control
1303          * 7~6 : Reserved
1304         */
1305         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1306         switch (tmp) {
1307         case 1:
1308                 spec->init_amp = ALC_INIT_GPIO1;
1309                 break;
1310         case 3:
1311                 spec->init_amp = ALC_INIT_GPIO2;
1312                 break;
1313         case 7:
1314                 spec->init_amp = ALC_INIT_GPIO3;
1315                 break;
1316         case 5:
1317                 spec->init_amp = ALC_INIT_DEFAULT;
1318                 break;
1319         }
1320
1321         /* is laptop or Desktop and enable the function "Mute internal speaker
1322          * when the external headphone out jack is plugged"
1323          */
1324         if (!(ass & 0x8000))
1325                 return 1;
1326         /*
1327          * 10~8 : Jack location
1328          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1329          * 14~13: Resvered
1330          * 15   : 1 --> enable the function "Mute internal speaker
1331          *              when the external headphone out jack is plugged"
1332          */
1333         if (!spec->autocfg.hp_pins[0]) {
1334                 hda_nid_t nid;
1335                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1336                 if (tmp == 0)
1337                         nid = porta;
1338                 else if (tmp == 1)
1339                         nid = porte;
1340                 else if (tmp == 2)
1341                         nid = portd;
1342                 else
1343                         return 1;
1344                 for (i = 0; i < spec->autocfg.line_outs; i++)
1345                         if (spec->autocfg.line_out_pins[i] == nid)
1346                                 return 1;
1347                 spec->autocfg.hp_pins[0] = nid;
1348         }
1349
1350         alc_init_auto_hp(codec);
1351         alc_init_auto_mic(codec);
1352         return 1;
1353 }
1354
1355 static void alc_ssid_check(struct hda_codec *codec,
1356                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1357 {
1358         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1359                 struct alc_spec *spec = codec->spec;
1360                 snd_printd("realtek: "
1361                            "Enable default setup for auto mode as fallback\n");
1362                 spec->init_amp = ALC_INIT_DEFAULT;
1363                 alc_init_auto_hp(codec);
1364                 alc_init_auto_mic(codec);
1365         }
1366 }
1367
1368 /*
1369  * Fix-up pin default configurations and add default verbs
1370  */
1371
1372 struct alc_pincfg {
1373         hda_nid_t nid;
1374         u32 val;
1375 };
1376
1377 struct alc_fixup {
1378         const struct alc_pincfg *pins;
1379         const struct hda_verb *verbs;
1380 };
1381
1382 static void alc_pick_fixup(struct hda_codec *codec,
1383                            const struct snd_pci_quirk *quirk,
1384                            const struct alc_fixup *fix)
1385 {
1386         const struct alc_pincfg *cfg;
1387
1388         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1389         if (!quirk)
1390                 return;
1391
1392         fix += quirk->value;
1393         cfg = fix->pins;
1394         if (cfg) {
1395                 for (; cfg->nid; cfg++)
1396                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1397         }
1398         if (fix->verbs)
1399                 add_verb(codec->spec, fix->verbs);
1400 }
1401
1402 static int alc_read_coef_idx(struct hda_codec *codec,
1403                         unsigned int coef_idx)
1404 {
1405         unsigned int val;
1406         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1407                                 coef_idx);
1408         val = snd_hda_codec_read(codec, 0x20, 0,
1409                                 AC_VERB_GET_PROC_COEF, 0);
1410         return val;
1411 }
1412
1413 /*
1414  * ALC888
1415  */
1416
1417 /*
1418  * 2ch mode
1419  */
1420 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1421 /* Mic-in jack as mic in */
1422         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1423         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1424 /* Line-in jack as Line in */
1425         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1426         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1427 /* Line-Out as Front */
1428         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1429         { } /* end */
1430 };
1431
1432 /*
1433  * 4ch mode
1434  */
1435 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1436 /* Mic-in jack as mic in */
1437         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1438         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1439 /* Line-in jack as Surround */
1440         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1441         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1442 /* Line-Out as Front */
1443         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1444         { } /* end */
1445 };
1446
1447 /*
1448  * 6ch mode
1449  */
1450 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1451 /* Mic-in jack as CLFE */
1452         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1453         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1454 /* Line-in jack as Surround */
1455         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1456         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1457 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1458         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1459         { } /* end */
1460 };
1461
1462 /*
1463  * 8ch mode
1464  */
1465 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1466 /* Mic-in jack as CLFE */
1467         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1468         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1469 /* Line-in jack as Surround */
1470         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1471         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1472 /* Line-Out as Side */
1473         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1474         { } /* end */
1475 };
1476
1477 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1478         { 2, alc888_4ST_ch2_intel_init },
1479         { 4, alc888_4ST_ch4_intel_init },
1480         { 6, alc888_4ST_ch6_intel_init },
1481         { 8, alc888_4ST_ch8_intel_init },
1482 };
1483
1484 /*
1485  * ALC888 Fujitsu Siemens Amillo xa3530
1486  */
1487
1488 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1489 /* Front Mic: set to PIN_IN (empty by default) */
1490         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1491 /* Connect Internal HP to Front */
1492         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1493         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1494         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1495 /* Connect Bass HP to Front */
1496         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1497         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1498         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1499 /* Connect Line-Out side jack (SPDIF) to Side */
1500         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1501         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1502         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1503 /* Connect Mic jack to CLFE */
1504         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1505         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1506         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1507 /* Connect Line-in jack to Surround */
1508         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1509         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1510         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1511 /* Connect HP out jack to Front */
1512         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1513         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1514         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1515 /* Enable unsolicited event for HP jack and Line-out jack */
1516         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1517         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1518         {}
1519 };
1520
1521 static void alc_automute_amp(struct hda_codec *codec)
1522 {
1523         struct alc_spec *spec = codec->spec;
1524         unsigned int mute;
1525         hda_nid_t nid;
1526         int i;
1527
1528         spec->jack_present = 0;
1529         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1530                 nid = spec->autocfg.hp_pins[i];
1531                 if (!nid)
1532                         break;
1533                 if (snd_hda_jack_detect(codec, nid)) {
1534                         spec->jack_present = 1;
1535                         break;
1536                 }
1537         }
1538
1539         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1540         /* Toggle internal speakers muting */
1541         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1542                 nid = spec->autocfg.speaker_pins[i];
1543                 if (!nid)
1544                         break;
1545                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1546                                          HDA_AMP_MUTE, mute);
1547         }
1548 }
1549
1550 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1551                                          unsigned int res)
1552 {
1553         if (codec->vendor_id == 0x10ec0880)
1554                 res >>= 28;
1555         else
1556                 res >>= 26;
1557         if (res == ALC880_HP_EVENT)
1558                 alc_automute_amp(codec);
1559 }
1560
1561 static void alc889_automute_setup(struct hda_codec *codec)
1562 {
1563         struct alc_spec *spec = codec->spec;
1564
1565         spec->autocfg.hp_pins[0] = 0x15;
1566         spec->autocfg.speaker_pins[0] = 0x14;
1567         spec->autocfg.speaker_pins[1] = 0x16;
1568         spec->autocfg.speaker_pins[2] = 0x17;
1569         spec->autocfg.speaker_pins[3] = 0x19;
1570         spec->autocfg.speaker_pins[4] = 0x1a;
1571 }
1572
1573 static void alc889_intel_init_hook(struct hda_codec *codec)
1574 {
1575         alc889_coef_init(codec);
1576         alc_automute_amp(codec);
1577 }
1578
1579 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1580 {
1581         struct alc_spec *spec = codec->spec;
1582
1583         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1584         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1585         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1586         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1587 }
1588
1589 /*
1590  * ALC888 Acer Aspire 4930G model
1591  */
1592
1593 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1594 /* Front Mic: set to PIN_IN (empty by default) */
1595         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1596 /* Unselect Front Mic by default in input mixer 3 */
1597         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1598 /* Enable unsolicited event for HP jack */
1599         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1600 /* Connect Internal HP to front */
1601         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1602         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1603         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1604 /* Connect HP out to front */
1605         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1606         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1607         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1608         { }
1609 };
1610
1611 /*
1612  * ALC888 Acer Aspire 6530G model
1613  */
1614
1615 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1616 /* Bias voltage on for external mic port */
1617         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1618 /* Front Mic: set to PIN_IN (empty by default) */
1619         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1620 /* Unselect Front Mic by default in input mixer 3 */
1621         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1622 /* Enable unsolicited event for HP jack */
1623         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1624 /* Enable speaker output */
1625         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1626         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1627 /* Enable headphone output */
1628         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1629         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1630         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1631         { }
1632 };
1633
1634 /*
1635  * ALC889 Acer Aspire 8930G model
1636  */
1637
1638 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1639 /* Front Mic: set to PIN_IN (empty by default) */
1640         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1641 /* Unselect Front Mic by default in input mixer 3 */
1642         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1643 /* Enable unsolicited event for HP jack */
1644         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1645 /* Connect Internal Front to Front */
1646         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1647         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1648         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1649 /* Connect Internal Rear to Rear */
1650         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1651         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1652         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1653 /* Connect Internal CLFE to CLFE */
1654         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1655         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1656         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1657 /* Connect HP out to Front */
1658         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1659         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1660         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1661 /* Enable all DACs */
1662 /*  DAC DISABLE/MUTE 1? */
1663 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1664         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1665         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1666 /*  DAC DISABLE/MUTE 2? */
1667 /*  some bit here disables the other DACs. Init=0x4900 */
1668         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1669         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1670 /* Enable amplifiers */
1671         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1672         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1673 /* DMIC fix
1674  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1675  * which makes the stereo useless. However, either the mic or the ALC889
1676  * makes the signal become a difference/sum signal instead of standard
1677  * stereo, which is annoying. So instead we flip this bit which makes the
1678  * codec replicate the sum signal to both channels, turning it into a
1679  * normal mono mic.
1680  */
1681 /*  DMIC_CONTROL? Init value = 0x0001 */
1682         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1683         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1684         { }
1685 };
1686
1687 static struct hda_input_mux alc888_2_capture_sources[2] = {
1688         /* Front mic only available on one ADC */
1689         {
1690                 .num_items = 4,
1691                 .items = {
1692                         { "Mic", 0x0 },
1693                         { "Line", 0x2 },
1694                         { "CD", 0x4 },
1695                         { "Front Mic", 0xb },
1696                 },
1697         },
1698         {
1699                 .num_items = 3,
1700                 .items = {
1701                         { "Mic", 0x0 },
1702                         { "Line", 0x2 },
1703                         { "CD", 0x4 },
1704                 },
1705         }
1706 };
1707
1708 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1709         /* Interal mic only available on one ADC */
1710         {
1711                 .num_items = 5,
1712                 .items = {
1713                         { "Ext Mic", 0x0 },
1714                         { "Line In", 0x2 },
1715                         { "CD", 0x4 },
1716                         { "Input Mix", 0xa },
1717                         { "Int Mic", 0xb },
1718                 },
1719         },
1720         {
1721                 .num_items = 4,
1722                 .items = {
1723                         { "Ext Mic", 0x0 },
1724                         { "Line In", 0x2 },
1725                         { "CD", 0x4 },
1726                         { "Input Mix", 0xa },
1727                 },
1728         }
1729 };
1730
1731 static struct hda_input_mux alc889_capture_sources[3] = {
1732         /* Digital mic only available on first "ADC" */
1733         {
1734                 .num_items = 5,
1735                 .items = {
1736                         { "Mic", 0x0 },
1737                         { "Line", 0x2 },
1738                         { "CD", 0x4 },
1739                         { "Front Mic", 0xb },
1740                         { "Input Mix", 0xa },
1741                 },
1742         },
1743         {
1744                 .num_items = 4,
1745                 .items = {
1746                         { "Mic", 0x0 },
1747                         { "Line", 0x2 },
1748                         { "CD", 0x4 },
1749                         { "Input Mix", 0xa },
1750                 },
1751         },
1752         {
1753                 .num_items = 4,
1754                 .items = {
1755                         { "Mic", 0x0 },
1756                         { "Line", 0x2 },
1757                         { "CD", 0x4 },
1758                         { "Input Mix", 0xa },
1759                 },
1760         }
1761 };
1762
1763 static struct snd_kcontrol_new alc888_base_mixer[] = {
1764         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1765         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1766         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1767         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1768         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1769                 HDA_OUTPUT),
1770         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1771         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1772         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1773         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1774         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1775         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1776         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1777         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1778         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1779         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1780         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1781         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1782         { } /* end */
1783 };
1784
1785 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1786 {
1787         struct alc_spec *spec = codec->spec;
1788
1789         spec->autocfg.hp_pins[0] = 0x15;
1790         spec->autocfg.speaker_pins[0] = 0x14;
1791         spec->autocfg.speaker_pins[1] = 0x16;
1792         spec->autocfg.speaker_pins[2] = 0x17;
1793 }
1794
1795 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1796 {
1797         struct alc_spec *spec = codec->spec;
1798
1799         spec->autocfg.hp_pins[0] = 0x15;
1800         spec->autocfg.speaker_pins[0] = 0x14;
1801         spec->autocfg.speaker_pins[1] = 0x16;
1802         spec->autocfg.speaker_pins[2] = 0x17;
1803 }
1804
1805 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1806 {
1807         struct alc_spec *spec = codec->spec;
1808
1809         spec->autocfg.hp_pins[0] = 0x15;
1810         spec->autocfg.speaker_pins[0] = 0x14;
1811         spec->autocfg.speaker_pins[1] = 0x16;
1812         spec->autocfg.speaker_pins[2] = 0x1b;
1813 }
1814
1815 /*
1816  * ALC880 3-stack model
1817  *
1818  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1819  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1820  *                 F-Mic = 0x1b, HP = 0x19
1821  */
1822
1823 static hda_nid_t alc880_dac_nids[4] = {
1824         /* front, rear, clfe, rear_surr */
1825         0x02, 0x05, 0x04, 0x03
1826 };
1827
1828 static hda_nid_t alc880_adc_nids[3] = {
1829         /* ADC0-2 */
1830         0x07, 0x08, 0x09,
1831 };
1832
1833 /* The datasheet says the node 0x07 is connected from inputs,
1834  * but it shows zero connection in the real implementation on some devices.
1835  * Note: this is a 915GAV bug, fixed on 915GLV
1836  */
1837 static hda_nid_t alc880_adc_nids_alt[2] = {
1838         /* ADC1-2 */
1839         0x08, 0x09,
1840 };
1841
1842 #define ALC880_DIGOUT_NID       0x06
1843 #define ALC880_DIGIN_NID        0x0a
1844
1845 static struct hda_input_mux alc880_capture_source = {
1846         .num_items = 4,
1847         .items = {
1848                 { "Mic", 0x0 },
1849                 { "Front Mic", 0x3 },
1850                 { "Line", 0x2 },
1851                 { "CD", 0x4 },
1852         },
1853 };
1854
1855 /* channel source setting (2/6 channel selection for 3-stack) */
1856 /* 2ch mode */
1857 static struct hda_verb alc880_threestack_ch2_init[] = {
1858         /* set line-in to input, mute it */
1859         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1860         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1861         /* set mic-in to input vref 80%, mute it */
1862         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1863         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1864         { } /* end */
1865 };
1866
1867 /* 6ch mode */
1868 static struct hda_verb alc880_threestack_ch6_init[] = {
1869         /* set line-in to output, unmute it */
1870         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1871         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1872         /* set mic-in to output, unmute it */
1873         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1874         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1875         { } /* end */
1876 };
1877
1878 static struct hda_channel_mode alc880_threestack_modes[2] = {
1879         { 2, alc880_threestack_ch2_init },
1880         { 6, alc880_threestack_ch6_init },
1881 };
1882
1883 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1884         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1885         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1886         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1887         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1888         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1889         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1890         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1891         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1892         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1893         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1894         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1895         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1896         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1897         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1898         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1899         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1900         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1901         {
1902                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1903                 .name = "Channel Mode",
1904                 .info = alc_ch_mode_info,
1905                 .get = alc_ch_mode_get,
1906                 .put = alc_ch_mode_put,
1907         },
1908         { } /* end */
1909 };
1910
1911 /* capture mixer elements */
1912 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1913                             struct snd_ctl_elem_info *uinfo)
1914 {
1915         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1916         struct alc_spec *spec = codec->spec;
1917         int err;
1918
1919         mutex_lock(&codec->control_mutex);
1920         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1921                                                       HDA_INPUT);
1922         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1923         mutex_unlock(&codec->control_mutex);
1924         return err;
1925 }
1926
1927 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1928                            unsigned int size, unsigned int __user *tlv)
1929 {
1930         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1931         struct alc_spec *spec = codec->spec;
1932         int err;
1933
1934         mutex_lock(&codec->control_mutex);
1935         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1936                                                       HDA_INPUT);
1937         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1938         mutex_unlock(&codec->control_mutex);
1939         return err;
1940 }
1941
1942 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1943                              struct snd_ctl_elem_value *ucontrol);
1944
1945 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1946                                  struct snd_ctl_elem_value *ucontrol,
1947                                  getput_call_t func)
1948 {
1949         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1950         struct alc_spec *spec = codec->spec;
1951         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1952         int err;
1953
1954         mutex_lock(&codec->control_mutex);
1955         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1956                                                       3, 0, HDA_INPUT);
1957         err = func(kcontrol, ucontrol);
1958         mutex_unlock(&codec->control_mutex);
1959         return err;
1960 }
1961
1962 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1963                            struct snd_ctl_elem_value *ucontrol)
1964 {
1965         return alc_cap_getput_caller(kcontrol, ucontrol,
1966                                      snd_hda_mixer_amp_volume_get);
1967 }
1968
1969 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1970                            struct snd_ctl_elem_value *ucontrol)
1971 {
1972         return alc_cap_getput_caller(kcontrol, ucontrol,
1973                                      snd_hda_mixer_amp_volume_put);
1974 }
1975
1976 /* capture mixer elements */
1977 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1978
1979 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1980                           struct snd_ctl_elem_value *ucontrol)
1981 {
1982         return alc_cap_getput_caller(kcontrol, ucontrol,
1983                                      snd_hda_mixer_amp_switch_get);
1984 }
1985
1986 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1987                           struct snd_ctl_elem_value *ucontrol)
1988 {
1989         return alc_cap_getput_caller(kcontrol, ucontrol,
1990                                      snd_hda_mixer_amp_switch_put);
1991 }
1992
1993 #define _DEFINE_CAPMIX(num) \
1994         { \
1995                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1996                 .name = "Capture Switch", \
1997                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1998                 .count = num, \
1999                 .info = alc_cap_sw_info, \
2000                 .get = alc_cap_sw_get, \
2001                 .put = alc_cap_sw_put, \
2002         }, \
2003         { \
2004                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2005                 .name = "Capture Volume", \
2006                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2007                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2008                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2009                 .count = num, \
2010                 .info = alc_cap_vol_info, \
2011                 .get = alc_cap_vol_get, \
2012                 .put = alc_cap_vol_put, \
2013                 .tlv = { .c = alc_cap_vol_tlv }, \
2014         }
2015
2016 #define _DEFINE_CAPSRC(num) \
2017         { \
2018                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2019                 /* .name = "Capture Source", */ \
2020                 .name = "Input Source", \
2021                 .count = num, \
2022                 .info = alc_mux_enum_info, \
2023                 .get = alc_mux_enum_get, \
2024                 .put = alc_mux_enum_put, \
2025         }
2026
2027 #define DEFINE_CAPMIX(num) \
2028 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2029         _DEFINE_CAPMIX(num),                                  \
2030         _DEFINE_CAPSRC(num),                                  \
2031         { } /* end */                                         \
2032 }
2033
2034 #define DEFINE_CAPMIX_NOSRC(num) \
2035 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2036         _DEFINE_CAPMIX(num),                                        \
2037         { } /* end */                                               \
2038 }
2039
2040 /* up to three ADCs */
2041 DEFINE_CAPMIX(1);
2042 DEFINE_CAPMIX(2);
2043 DEFINE_CAPMIX(3);
2044 DEFINE_CAPMIX_NOSRC(1);
2045 DEFINE_CAPMIX_NOSRC(2);
2046 DEFINE_CAPMIX_NOSRC(3);
2047
2048 /*
2049  * ALC880 5-stack model
2050  *
2051  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2052  *      Side = 0x02 (0xd)
2053  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2054  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2055  */
2056
2057 /* additional mixers to alc880_three_stack_mixer */
2058 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2059         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2060         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2061         { } /* end */
2062 };
2063
2064 /* channel source setting (6/8 channel selection for 5-stack) */
2065 /* 6ch mode */
2066 static struct hda_verb alc880_fivestack_ch6_init[] = {
2067         /* set line-in to input, mute it */
2068         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2069         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2070         { } /* end */
2071 };
2072
2073 /* 8ch mode */
2074 static struct hda_verb alc880_fivestack_ch8_init[] = {
2075         /* set line-in to output, unmute it */
2076         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2077         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2078         { } /* end */
2079 };
2080
2081 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2082         { 6, alc880_fivestack_ch6_init },
2083         { 8, alc880_fivestack_ch8_init },
2084 };
2085
2086
2087 /*
2088  * ALC880 6-stack model
2089  *
2090  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2091  *      Side = 0x05 (0x0f)
2092  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2093  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2094  */
2095
2096 static hda_nid_t alc880_6st_dac_nids[4] = {
2097         /* front, rear, clfe, rear_surr */
2098         0x02, 0x03, 0x04, 0x05
2099 };
2100
2101 static struct hda_input_mux alc880_6stack_capture_source = {
2102         .num_items = 4,
2103         .items = {
2104                 { "Mic", 0x0 },
2105                 { "Front Mic", 0x1 },
2106                 { "Line", 0x2 },
2107                 { "CD", 0x4 },
2108         },
2109 };
2110
2111 /* fixed 8-channels */
2112 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2113         { 8, NULL },
2114 };
2115
2116 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2117         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2118         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2119         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2120         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2121         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2122         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2123         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2124         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2125         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2126         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2127         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2128         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2129         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2130         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2131         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2132         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2133         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2134         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2135         {
2136                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2137                 .name = "Channel Mode",
2138                 .info = alc_ch_mode_info,
2139                 .get = alc_ch_mode_get,
2140                 .put = alc_ch_mode_put,
2141         },
2142         { } /* end */
2143 };
2144
2145
2146 /*
2147  * ALC880 W810 model
2148  *
2149  * W810 has rear IO for:
2150  * Front (DAC 02)
2151  * Surround (DAC 03)
2152  * Center/LFE (DAC 04)
2153  * Digital out (06)
2154  *
2155  * The system also has a pair of internal speakers, and a headphone jack.
2156  * These are both connected to Line2 on the codec, hence to DAC 02.
2157  *
2158  * There is a variable resistor to control the speaker or headphone
2159  * volume. This is a hardware-only device without a software API.
2160  *
2161  * Plugging headphones in will disable the internal speakers. This is
2162  * implemented in hardware, not via the driver using jack sense. In
2163  * a similar fashion, plugging into the rear socket marked "front" will
2164  * disable both the speakers and headphones.
2165  *
2166  * For input, there's a microphone jack, and an "audio in" jack.
2167  * These may not do anything useful with this driver yet, because I
2168  * haven't setup any initialization verbs for these yet...
2169  */
2170
2171 static hda_nid_t alc880_w810_dac_nids[3] = {
2172         /* front, rear/surround, clfe */
2173         0x02, 0x03, 0x04
2174 };
2175
2176 /* fixed 6 channels */
2177 static struct hda_channel_mode alc880_w810_modes[1] = {
2178         { 6, NULL }
2179 };
2180
2181 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2182 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2183         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2184         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2185         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2186         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2187         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2188         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2189         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2190         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2191         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2192         { } /* end */
2193 };
2194
2195
2196 /*
2197  * Z710V model
2198  *
2199  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2200  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2201  *                 Line = 0x1a
2202  */
2203
2204 static hda_nid_t alc880_z71v_dac_nids[1] = {
2205         0x02
2206 };
2207 #define ALC880_Z71V_HP_DAC      0x03
2208
2209 /* fixed 2 channels */
2210 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2211         { 2, NULL }
2212 };
2213
2214 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2216         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2217         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2218         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2219         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2220         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2221         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2223         { } /* end */
2224 };
2225
2226
2227 /*
2228  * ALC880 F1734 model
2229  *
2230  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2231  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2232  */
2233
2234 static hda_nid_t alc880_f1734_dac_nids[1] = {
2235         0x03
2236 };
2237 #define ALC880_F1734_HP_DAC     0x02
2238
2239 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2240         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2241         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2242         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2243         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2244         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2245         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2246         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2247         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2248         { } /* end */
2249 };
2250
2251 static struct hda_input_mux alc880_f1734_capture_source = {
2252         .num_items = 2,
2253         .items = {
2254                 { "Mic", 0x1 },
2255                 { "CD", 0x4 },
2256         },
2257 };
2258
2259
2260 /*
2261  * ALC880 ASUS model
2262  *
2263  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2264  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2265  *  Mic = 0x18, Line = 0x1a
2266  */
2267
2268 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2269 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2270
2271 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2272         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2273         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2274         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2275         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2276         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2277         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2278         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2279         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2280         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2281         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2282         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2283         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2284         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2285         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2286         {
2287                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2288                 .name = "Channel Mode",
2289                 .info = alc_ch_mode_info,
2290                 .get = alc_ch_mode_get,
2291                 .put = alc_ch_mode_put,
2292         },
2293         { } /* end */
2294 };
2295
2296 /*
2297  * ALC880 ASUS W1V model
2298  *
2299  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2300  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2301  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2302  */
2303
2304 /* additional mixers to alc880_asus_mixer */
2305 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2306         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2307         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2308         { } /* end */
2309 };
2310
2311 /* TCL S700 */
2312 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2313         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2314         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2315         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2316         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2317         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2318         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2319         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2320         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2321         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2322         { } /* end */
2323 };
2324
2325 /* Uniwill */
2326 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2327         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2328         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2329         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2330         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2331         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2332         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2333         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2334         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2335         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2336         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2337         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2338         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2339         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2340         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2341         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2342         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2343         {
2344                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2345                 .name = "Channel Mode",
2346                 .info = alc_ch_mode_info,
2347                 .get = alc_ch_mode_get,
2348                 .put = alc_ch_mode_put,
2349         },
2350         { } /* end */
2351 };
2352
2353 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2354         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2355         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2356         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2357         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2358         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2359         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2360         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2361         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2362         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2363         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2364         { } /* end */
2365 };
2366
2367 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2368         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2369         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2370         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2371         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2372         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2373         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2374         { } /* end */
2375 };
2376
2377 /*
2378  * virtual master controls
2379  */
2380
2381 /*
2382  * slave controls for virtual master
2383  */
2384 static const char *alc_slave_vols[] = {
2385         "Front Playback Volume",
2386         "Surround Playback Volume",
2387         "Center Playback Volume",
2388         "LFE Playback Volume",
2389         "Side Playback Volume",
2390         "Headphone Playback Volume",
2391         "Speaker Playback Volume",
2392         "Mono Playback Volume",
2393         "Line-Out Playback Volume",
2394         "PCM Playback Volume",
2395         NULL,
2396 };
2397
2398 static const char *alc_slave_sws[] = {
2399         "Front Playback Switch",
2400         "Surround Playback Switch",
2401         "Center Playback Switch",
2402         "LFE Playback Switch",
2403         "Side Playback Switch",
2404         "Headphone Playback Switch",
2405         "Speaker Playback Switch",
2406         "Mono Playback Switch",
2407         "IEC958 Playback Switch",
2408         "Line-Out Playback Switch",
2409         "PCM Playback Switch",
2410         NULL,
2411 };
2412
2413 /*
2414  * build control elements
2415  */
2416
2417 #define NID_MAPPING             (-1)
2418
2419 #define SUBDEV_SPEAKER_         (0 << 6)
2420 #define SUBDEV_HP_              (1 << 6)
2421 #define SUBDEV_LINE_            (2 << 6)
2422 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2423 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2424 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2425
2426 static void alc_free_kctls(struct hda_codec *codec);
2427
2428 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2429 /* additional beep mixers; the actual parameters are overwritten at build */
2430 static struct snd_kcontrol_new alc_beep_mixer[] = {
2431         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2432         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2433         { } /* end */
2434 };
2435 #endif
2436
2437 static int alc_build_controls(struct hda_codec *codec)
2438 {
2439         struct alc_spec *spec = codec->spec;
2440         struct snd_kcontrol *kctl;
2441         struct snd_kcontrol_new *knew;
2442         int i, j, err;
2443         unsigned int u;
2444         hda_nid_t nid;
2445
2446         for (i = 0; i < spec->num_mixers; i++) {
2447                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2448                 if (err < 0)
2449                         return err;
2450         }
2451         if (spec->cap_mixer) {
2452                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2453                 if (err < 0)
2454                         return err;
2455         }
2456         if (spec->multiout.dig_out_nid) {
2457                 err = snd_hda_create_spdif_out_ctls(codec,
2458                                                     spec->multiout.dig_out_nid);
2459                 if (err < 0)
2460                         return err;
2461                 if (!spec->no_analog) {
2462                         err = snd_hda_create_spdif_share_sw(codec,
2463                                                             &spec->multiout);
2464                         if (err < 0)
2465                                 return err;
2466                         spec->multiout.share_spdif = 1;
2467                 }
2468         }
2469         if (spec->dig_in_nid) {
2470                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2471                 if (err < 0)
2472                         return err;
2473         }
2474
2475 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2476         /* create beep controls if needed */
2477         if (spec->beep_amp) {
2478                 struct snd_kcontrol_new *knew;
2479                 for (knew = alc_beep_mixer; knew->name; knew++) {
2480                         struct snd_kcontrol *kctl;
2481                         kctl = snd_ctl_new1(knew, codec);
2482                         if (!kctl)
2483                                 return -ENOMEM;
2484                         kctl->private_value = spec->beep_amp;
2485                         err = snd_hda_ctl_add(codec,
2486                                         get_amp_nid_(spec->beep_amp), kctl);
2487                         if (err < 0)
2488                                 return err;
2489                 }
2490         }
2491 #endif
2492
2493         /* if we have no master control, let's create it */
2494         if (!spec->no_analog &&
2495             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2496                 unsigned int vmaster_tlv[4];
2497                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2498                                         HDA_OUTPUT, vmaster_tlv);
2499                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2500                                           vmaster_tlv, alc_slave_vols);
2501                 if (err < 0)
2502                         return err;
2503         }
2504         if (!spec->no_analog &&
2505             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2506                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2507                                           NULL, alc_slave_sws);
2508                 if (err < 0)
2509                         return err;
2510         }
2511
2512         alc_free_kctls(codec); /* no longer needed */
2513
2514         /* assign Capture Source enums to NID */
2515         kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2516         if (!kctl)
2517                 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2518         for (i = 0; kctl && i < kctl->count; i++) {
2519                 err = snd_hda_add_nids(codec, kctl, i, spec->capsrc_nids,
2520                                        spec->input_mux->num_items);
2521                 if (err < 0)
2522                         return err;
2523         }
2524         if (spec->cap_mixer) {
2525                 const char *kname = kctl ? kctl->id.name : NULL;
2526                 for (knew = spec->cap_mixer; knew->name; knew++) {
2527                         if (kname && strcmp(knew->name, kname) == 0)
2528                                 continue;
2529                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2530                         for (i = 0; kctl && i < kctl->count; i++) {
2531                                 err = snd_hda_add_nid(codec, kctl, i,
2532                                                       spec->adc_nids[i]);
2533                                 if (err < 0)
2534                                         return err;
2535                         }
2536                 }
2537         }
2538
2539         /* other nid->control mapping */
2540         for (i = 0; i < spec->num_mixers; i++) {
2541                 for (knew = spec->mixers[i]; knew->name; knew++) {
2542                         if (knew->iface != NID_MAPPING)
2543                                 continue;
2544                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2545                         if (kctl == NULL)
2546                                 continue;
2547                         u = knew->subdevice;
2548                         for (j = 0; j < 4; j++, u >>= 8) {
2549                                 nid = u & 0x3f;
2550                                 if (nid == 0)
2551                                         continue;
2552                                 switch (u & 0xc0) {
2553                                 case SUBDEV_SPEAKER_:
2554                                         nid = spec->autocfg.speaker_pins[nid];
2555                                         break;
2556                                 case SUBDEV_LINE_:
2557                                         nid = spec->autocfg.line_out_pins[nid];
2558                                         break;
2559                                 case SUBDEV_HP_:
2560                                         nid = spec->autocfg.hp_pins[nid];
2561                                         break;
2562                                 default:
2563                                         continue;
2564                                 }
2565                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2566                                 if (err < 0)
2567                                         return err;
2568                         }
2569                         u = knew->private_value;
2570                         for (j = 0; j < 4; j++, u >>= 8) {
2571                                 nid = u & 0xff;
2572                                 if (nid == 0)
2573                                         continue;
2574                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2575                                 if (err < 0)
2576                                         return err;
2577                         }
2578                 }
2579         }
2580         return 0;
2581 }
2582
2583
2584 /*
2585  * initialize the codec volumes, etc
2586  */
2587
2588 /*
2589  * generic initialization of ADC, input mixers and output mixers
2590  */
2591 static struct hda_verb alc880_volume_init_verbs[] = {
2592         /*
2593          * Unmute ADC0-2 and set the default input to mic-in
2594          */
2595         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2596         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2597         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2598         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2599         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2600         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2601
2602         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2603          * mixer widget
2604          * Note: PASD motherboards uses the Line In 2 as the input for front
2605          * panel mic (mic 2)
2606          */
2607         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2609         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2610         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2611         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2612         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2613         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2614         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2615
2616         /*
2617          * Set up output mixers (0x0c - 0x0f)
2618          */
2619         /* set vol=0 to output mixers */
2620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2621         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2622         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2623         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2624         /* set up input amps for analog loopback */
2625         /* Amp Indices: DAC = 0, mixer = 1 */
2626         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2628         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2629         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2630         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2631         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2632         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2633         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2634
2635         { }
2636 };
2637
2638 /*
2639  * 3-stack pin configuration:
2640  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2641  */
2642 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2643         /*
2644          * preset connection lists of input pins
2645          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2646          */
2647         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2648         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2649         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2650
2651         /*
2652          * Set pin mode and muting
2653          */
2654         /* set front pin widgets 0x14 for output */
2655         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2656         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2657         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2658         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2659         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2660         /* Mic2 (as headphone out) for HP output */
2661         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2662         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2663         /* Line In pin widget for input */
2664         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2665         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2666         /* Line2 (as front mic) pin widget for input and vref at 80% */
2667         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2668         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2669         /* CD pin widget for input */
2670         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2671
2672         { }
2673 };
2674
2675 /*
2676  * 5-stack pin configuration:
2677  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2678  * line-in/side = 0x1a, f-mic = 0x1b
2679  */
2680 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2681         /*
2682          * preset connection lists of input pins
2683          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2684          */
2685         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2686         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2687
2688         /*
2689          * Set pin mode and muting
2690          */
2691         /* set pin widgets 0x14-0x17 for output */
2692         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2693         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2694         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2695         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2696         /* unmute pins for output (no gain on this amp) */
2697         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2698         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2699         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2700         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2701
2702         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2703         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2704         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2705         /* Mic2 (as headphone out) for HP output */
2706         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2707         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2708         /* Line In pin widget for input */
2709         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2710         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2711         /* Line2 (as front mic) pin widget for input and vref at 80% */
2712         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2713         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2714         /* CD pin widget for input */
2715         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2716
2717         { }
2718 };
2719
2720 /*
2721  * W810 pin configuration:
2722  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2723  */
2724 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2725         /* hphone/speaker input selector: front DAC */
2726         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2727
2728         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2730         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2731         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2732         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2733         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734
2735         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2736         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2737
2738         { }
2739 };
2740
2741 /*
2742  * Z71V pin configuration:
2743  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2744  */
2745 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2746         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2747         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2748         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2749         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2750
2751         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2752         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2753         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2754         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2755
2756         { }
2757 };
2758
2759 /*
2760  * 6-stack pin configuration:
2761  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2762  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2763  */
2764 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2765         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2766
2767         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2768         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2769         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2770         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2771         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2772         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2773         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2774         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2775
2776         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2777         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2778         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2779         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2780         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2781         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2782         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2783         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2784         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2785
2786         { }
2787 };
2788
2789 /*
2790  * Uniwill pin configuration:
2791  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2792  * line = 0x1a
2793  */
2794 static struct hda_verb alc880_uniwill_init_verbs[] = {
2795         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2796
2797         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2798         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2799         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2801         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2802         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2803         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2804         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2805         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2806         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2807         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2808         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2809         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2810         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2811
2812         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2813         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2814         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2815         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2816         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2817         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2818         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2819         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2820         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2821
2822         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2823         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2824
2825         { }
2826 };
2827
2828 /*
2829 * Uniwill P53
2830 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2831  */
2832 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2833         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2834
2835         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2836         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2837         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2838         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2839         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2840         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2841         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2842         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2843         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2844         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2845         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2846         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2847
2848         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2849         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2850         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2851         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2852         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2853         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2854
2855         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2856         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2857
2858         { }
2859 };
2860
2861 static struct hda_verb alc880_beep_init_verbs[] = {
2862         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2863         { }
2864 };
2865
2866 /* auto-toggle front mic */
2867 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2868 {
2869         unsigned int present;
2870         unsigned char bits;
2871
2872         present = snd_hda_jack_detect(codec, 0x18);
2873         bits = present ? HDA_AMP_MUTE : 0;
2874         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2875 }
2876
2877 static void alc880_uniwill_setup(struct hda_codec *codec)
2878 {
2879         struct alc_spec *spec = codec->spec;
2880
2881         spec->autocfg.hp_pins[0] = 0x14;
2882         spec->autocfg.speaker_pins[0] = 0x15;
2883         spec->autocfg.speaker_pins[0] = 0x16;
2884 }
2885
2886 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2887 {
2888         alc_automute_amp(codec);
2889         alc880_uniwill_mic_automute(codec);
2890 }
2891
2892 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2893                                        unsigned int res)
2894 {
2895         /* Looks like the unsol event is incompatible with the standard
2896          * definition.  4bit tag is placed at 28 bit!
2897          */
2898         switch (res >> 28) {
2899         case ALC880_MIC_EVENT:
2900                 alc880_uniwill_mic_automute(codec);
2901                 break;
2902         default:
2903                 alc_automute_amp_unsol_event(codec, res);
2904                 break;
2905         }
2906 }
2907
2908 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2909 {
2910         struct alc_spec *spec = codec->spec;
2911
2912         spec->autocfg.hp_pins[0] = 0x14;
2913         spec->autocfg.speaker_pins[0] = 0x15;
2914 }
2915
2916 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2917 {
2918         unsigned int present;
2919
2920         present = snd_hda_codec_read(codec, 0x21, 0,
2921                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2922         present &= HDA_AMP_VOLMASK;
2923         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2924                                  HDA_AMP_VOLMASK, present);
2925         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2926                                  HDA_AMP_VOLMASK, present);
2927 }
2928
2929 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2930                                            unsigned int res)
2931 {
2932         /* Looks like the unsol event is incompatible with the standard
2933          * definition.  4bit tag is placed at 28 bit!
2934          */
2935         if ((res >> 28) == ALC880_DCVOL_EVENT)
2936                 alc880_uniwill_p53_dcvol_automute(codec);
2937         else
2938                 alc_automute_amp_unsol_event(codec, res);
2939 }
2940
2941 /*
2942  * F1734 pin configuration:
2943  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2944  */
2945 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2946         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2947         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2948         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2949         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2950         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2951
2952         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2953         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2954         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2955         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2956
2957         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2958         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2959         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2960         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2961         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2962         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2963         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2964         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2965         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2966
2967         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2968         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2969
2970         { }
2971 };
2972
2973 /*
2974  * ASUS pin configuration:
2975  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2976  */
2977 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2978         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2979         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2980         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2981         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2982
2983         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2984         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2985         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2986         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2987         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2988         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2989         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2990         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2991
2992         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2993         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2994         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2995         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2996         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2997         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2998         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2999         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3000         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3001
3002         { }
3003 };
3004
3005 /* Enable GPIO mask and set output */
3006 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3007 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3008 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3009
3010 /* Clevo m520g init */
3011 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3012         /* headphone output */
3013         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3014         /* line-out */
3015         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3017         /* Line-in */
3018         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3019         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3020         /* CD */
3021         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3022         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3023         /* Mic1 (rear panel) */
3024         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3025         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3026         /* Mic2 (front panel) */
3027         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3028         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3029         /* headphone */
3030         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3031         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3032         /* change to EAPD mode */
3033         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3034         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3035
3036         { }
3037 };
3038
3039 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3040         /* change to EAPD mode */
3041         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3042         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3043
3044         /* Headphone output */
3045         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3046         /* Front output*/
3047         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3048         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3049
3050         /* Line In pin widget for input */
3051         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3052         /* CD pin widget for input */
3053         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3054         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3055         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3056
3057         /* change to EAPD mode */
3058         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3059         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3060
3061         { }
3062 };
3063
3064 /*
3065  * LG m1 express dual
3066  *
3067  * Pin assignment:
3068  *   Rear Line-In/Out (blue): 0x14
3069  *   Build-in Mic-In: 0x15
3070  *   Speaker-out: 0x17
3071  *   HP-Out (green): 0x1b
3072  *   Mic-In/Out (red): 0x19
3073  *   SPDIF-Out: 0x1e
3074  */
3075
3076 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3077 static hda_nid_t alc880_lg_dac_nids[3] = {
3078         0x05, 0x02, 0x03
3079 };
3080
3081 /* seems analog CD is not working */
3082 static struct hda_input_mux alc880_lg_capture_source = {
3083         .num_items = 3,
3084         .items = {
3085                 { "Mic", 0x1 },
3086                 { "Line", 0x5 },
3087                 { "Internal Mic", 0x6 },
3088         },
3089 };
3090
3091 /* 2,4,6 channel modes */
3092 static struct hda_verb alc880_lg_ch2_init[] = {
3093         /* set line-in and mic-in to input */
3094         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3095         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3096         { }
3097 };
3098
3099 static struct hda_verb alc880_lg_ch4_init[] = {
3100         /* set line-in to out and mic-in to input */
3101         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3102         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3103         { }
3104 };
3105
3106 static struct hda_verb alc880_lg_ch6_init[] = {
3107         /* set line-in and mic-in to output */
3108         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3109         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3110         { }
3111 };
3112
3113 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3114         { 2, alc880_lg_ch2_init },
3115         { 4, alc880_lg_ch4_init },
3116         { 6, alc880_lg_ch6_init },
3117 };
3118
3119 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3120         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3121         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3122         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3123         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3124         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3125         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3126         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3127         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3128         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3129         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3130         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3131         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3132         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3133         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3134         {
3135                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3136                 .name = "Channel Mode",
3137                 .info = alc_ch_mode_info,
3138                 .get = alc_ch_mode_get,
3139                 .put = alc_ch_mode_put,
3140         },
3141         { } /* end */
3142 };
3143
3144 static struct hda_verb alc880_lg_init_verbs[] = {
3145         /* set capture source to mic-in */
3146         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3147         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3148         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3149         /* mute all amp mixer inputs */
3150         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3151         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3152         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3153         /* line-in to input */
3154         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3155         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3156         /* built-in mic */
3157         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3158         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3159         /* speaker-out */
3160         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3161         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3162         /* mic-in to input */
3163         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3164         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3165         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3166         /* HP-out */
3167         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3168         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3169         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3170         /* jack sense */
3171         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3172         { }
3173 };
3174
3175 /* toggle speaker-output according to the hp-jack state */
3176 static void alc880_lg_setup(struct hda_codec *codec)
3177 {
3178         struct alc_spec *spec = codec->spec;
3179
3180         spec->autocfg.hp_pins[0] = 0x1b;
3181         spec->autocfg.speaker_pins[0] = 0x17;
3182 }
3183
3184 /*
3185  * LG LW20
3186  *
3187  * Pin assignment:
3188  *   Speaker-out: 0x14
3189  *   Mic-In: 0x18
3190  *   Built-in Mic-In: 0x19
3191  *   Line-In: 0x1b
3192  *   HP-Out: 0x1a
3193  *   SPDIF-Out: 0x1e
3194  */
3195
3196 static struct hda_input_mux alc880_lg_lw_capture_source = {
3197         .num_items = 3,
3198         .items = {
3199                 { "Mic", 0x0 },
3200                 { "Internal Mic", 0x1 },
3201                 { "Line In", 0x2 },
3202         },
3203 };
3204
3205 #define alc880_lg_lw_modes alc880_threestack_modes
3206
3207 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3208         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3209         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3210         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3211         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3212         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3213         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3214         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3215         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3216         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3217         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3218         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3219         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3220         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3221         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3222         {
3223                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3224                 .name = "Channel Mode",
3225                 .info = alc_ch_mode_info,
3226                 .get = alc_ch_mode_get,
3227                 .put = alc_ch_mode_put,
3228         },
3229         { } /* end */
3230 };
3231
3232 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3233         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3234         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3235         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3236
3237         /* set capture source to mic-in */
3238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3239         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3240         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3241         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3242         /* speaker-out */
3243         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3244         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3245         /* HP-out */
3246         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3247         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3248         /* mic-in to input */
3249         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3250         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3251         /* built-in mic */
3252         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3253         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3254         /* jack sense */
3255         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3256         { }
3257 };
3258
3259 /* toggle speaker-output according to the hp-jack state */
3260 static void alc880_lg_lw_setup(struct hda_codec *codec)
3261 {
3262         struct alc_spec *spec = codec->spec;
3263
3264         spec->autocfg.hp_pins[0] = 0x1b;
3265         spec->autocfg.speaker_pins[0] = 0x14;
3266 }
3267
3268 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3269         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3270         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3273         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3274         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3275         { } /* end */
3276 };
3277
3278 static struct hda_input_mux alc880_medion_rim_capture_source = {
3279         .num_items = 2,
3280         .items = {
3281                 { "Mic", 0x0 },
3282                 { "Internal Mic", 0x1 },
3283         },
3284 };
3285
3286 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3287         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3288
3289         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3290         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3291
3292         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3293         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3294         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3295         /* Mic2 (as headphone out) for HP output */
3296         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3297         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3298         /* Internal Speaker */
3299         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3300         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3301
3302         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3303         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3304
3305         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3306         { }
3307 };
3308
3309 /* toggle speaker-output according to the hp-jack state */
3310 static void alc880_medion_rim_automute(struct hda_codec *codec)
3311 {
3312         struct alc_spec *spec = codec->spec;
3313         alc_automute_amp(codec);
3314         /* toggle EAPD */
3315         if (spec->jack_present)
3316                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3317         else
3318                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3319 }
3320
3321 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3322                                           unsigned int res)
3323 {
3324         /* Looks like the unsol event is incompatible with the standard
3325          * definition.  4bit tag is placed at 28 bit!
3326          */
3327         if ((res >> 28) == ALC880_HP_EVENT)
3328                 alc880_medion_rim_automute(codec);
3329 }
3330
3331 static void alc880_medion_rim_setup(struct hda_codec *codec)
3332 {
3333         struct alc_spec *spec = codec->spec;
3334
3335         spec->autocfg.hp_pins[0] = 0x14;
3336         spec->autocfg.speaker_pins[0] = 0x1b;
3337 }
3338
3339 #ifdef CONFIG_SND_HDA_POWER_SAVE
3340 static struct hda_amp_list alc880_loopbacks[] = {
3341         { 0x0b, HDA_INPUT, 0 },
3342         { 0x0b, HDA_INPUT, 1 },
3343         { 0x0b, HDA_INPUT, 2 },
3344         { 0x0b, HDA_INPUT, 3 },
3345         { 0x0b, HDA_INPUT, 4 },
3346         { } /* end */
3347 };
3348
3349 static struct hda_amp_list alc880_lg_loopbacks[] = {
3350         { 0x0b, HDA_INPUT, 1 },
3351         { 0x0b, HDA_INPUT, 6 },
3352         { 0x0b, HDA_INPUT, 7 },
3353         { } /* end */
3354 };
3355 #endif
3356
3357 /*
3358  * Common callbacks
3359  */
3360
3361 static int alc_init(struct hda_codec *codec)
3362 {
3363         struct alc_spec *spec = codec->spec;
3364         unsigned int i;
3365
3366         alc_fix_pll(codec);
3367         alc_auto_init_amp(codec, spec->init_amp);
3368
3369         for (i = 0; i < spec->num_init_verbs; i++)
3370                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3371
3372         if (spec->init_hook)
3373                 spec->init_hook(codec);
3374
3375         return 0;
3376 }
3377
3378 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3379 {
3380         struct alc_spec *spec = codec->spec;
3381
3382         if (spec->unsol_event)
3383                 spec->unsol_event(codec, res);
3384 }
3385
3386 #ifdef CONFIG_SND_HDA_POWER_SAVE
3387 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3388 {
3389         struct alc_spec *spec = codec->spec;
3390         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3391 }
3392 #endif
3393
3394 /*
3395  * Analog playback callbacks
3396  */
3397 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3398                                     struct hda_codec *codec,
3399                                     struct snd_pcm_substream *substream)
3400 {
3401         struct alc_spec *spec = codec->spec;
3402         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3403                                              hinfo);
3404 }
3405
3406 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3407                                        struct hda_codec *codec,
3408                                        unsigned int stream_tag,
3409                                        unsigned int format,
3410                                        struct snd_pcm_substream *substream)
3411 {
3412         struct alc_spec *spec = codec->spec;
3413         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3414                                                 stream_tag, format, substream);
3415 }
3416
3417 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3418                                        struct hda_codec *codec,
3419                                        struct snd_pcm_substream *substream)
3420 {
3421         struct alc_spec *spec = codec->spec;
3422         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3423 }
3424
3425 /*
3426  * Digital out
3427  */
3428 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3429                                         struct hda_codec *codec,
3430                                         struct snd_pcm_substream *substream)
3431 {
3432         struct alc_spec *spec = codec->spec;
3433         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3434 }
3435
3436 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3437                                            struct hda_codec *codec,
3438                                            unsigned int stream_tag,
3439                                            unsigned int format,
3440                                            struct snd_pcm_substream *substream)
3441 {
3442         struct alc_spec *spec = codec->spec;
3443         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3444                                              stream_tag, format, substream);
3445 }
3446
3447 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3448                                            struct hda_codec *codec,
3449                                            struct snd_pcm_substream *substream)
3450 {
3451         struct alc_spec *spec = codec->spec;
3452         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3453 }
3454
3455 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3456                                          struct hda_codec *codec,
3457                                          struct snd_pcm_substream *substream)
3458 {
3459         struct alc_spec *spec = codec->spec;
3460         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3461 }
3462
3463 /*
3464  * Analog capture
3465  */
3466 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3467                                       struct hda_codec *codec,
3468                                       unsigned int stream_tag,
3469                                       unsigned int format,
3470                                       struct snd_pcm_substream *substream)
3471 {
3472         struct alc_spec *spec = codec->spec;
3473
3474         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3475                                    stream_tag, 0, format);
3476         return 0;
3477 }
3478
3479 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3480                                       struct hda_codec *codec,
3481                                       struct snd_pcm_substream *substream)
3482 {
3483         struct alc_spec *spec = codec->spec;
3484
3485         snd_hda_codec_cleanup_stream(codec,
3486                                      spec->adc_nids[substream->number + 1]);
3487         return 0;
3488 }
3489
3490
3491 /*
3492  */
3493 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3494         .substreams = 1,
3495         .channels_min = 2,
3496         .channels_max = 8,
3497         /* NID is set in alc_build_pcms */
3498         .ops = {
3499                 .open = alc880_playback_pcm_open,
3500                 .prepare = alc880_playback_pcm_prepare,
3501                 .cleanup = alc880_playback_pcm_cleanup
3502         },
3503 };
3504
3505 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3506         .substreams = 1,
3507         .channels_min = 2,
3508         .channels_max = 2,
3509         /* NID is set in alc_build_pcms */
3510 };
3511
3512 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3513         .substreams = 1,
3514         .channels_min = 2,
3515         .channels_max = 2,
3516         /* NID is set in alc_build_pcms */
3517 };
3518
3519 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3520         .substreams = 2, /* can be overridden */
3521         .channels_min = 2,
3522         .channels_max = 2,
3523         /* NID is set in alc_build_pcms */
3524         .ops = {
3525                 .prepare = alc880_alt_capture_pcm_prepare,
3526                 .cleanup = alc880_alt_capture_pcm_cleanup
3527         },
3528 };
3529
3530 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3531         .substreams = 1,
3532         .channels_min = 2,
3533         .channels_max = 2,
3534         /* NID is set in alc_build_pcms */
3535         .ops = {
3536                 .open = alc880_dig_playback_pcm_open,
3537                 .close = alc880_dig_playback_pcm_close,
3538                 .prepare = alc880_dig_playback_pcm_prepare,
3539                 .cleanup = alc880_dig_playback_pcm_cleanup
3540         },
3541 };
3542
3543 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3544         .substreams = 1,
3545         .channels_min = 2,
3546         .channels_max = 2,
3547         /* NID is set in alc_build_pcms */
3548 };
3549
3550 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3551 static struct hda_pcm_stream alc_pcm_null_stream = {
3552         .substreams = 0,
3553         .channels_min = 0,
3554         .channels_max = 0,
3555 };
3556
3557 static int alc_build_pcms(struct hda_codec *codec)
3558 {
3559         struct alc_spec *spec = codec->spec;
3560         struct hda_pcm *info = spec->pcm_rec;
3561         int i;
3562
3563         codec->num_pcms = 1;
3564         codec->pcm_info = info;
3565
3566         if (spec->no_analog)
3567                 goto skip_analog;
3568
3569         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3570                  "%s Analog", codec->chip_name);
3571         info->name = spec->stream_name_analog;
3572
3573         if (spec->stream_analog_playback) {
3574                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3575                         return -EINVAL;
3576                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3577                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3578         }
3579         if (spec->stream_analog_capture) {
3580                 if (snd_BUG_ON(!spec->adc_nids))
3581                         return -EINVAL;
3582                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3583                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3584         }
3585
3586         if (spec->channel_mode) {
3587                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3588                 for (i = 0; i < spec->num_channel_mode; i++) {
3589                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3590                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3591                         }
3592                 }
3593         }
3594
3595  skip_analog:
3596         /* SPDIF for stream index #1 */
3597         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3598                 snprintf(spec->stream_name_digital,
3599                          sizeof(spec->stream_name_digital),
3600                          "%s Digital", codec->chip_name);
3601                 codec->num_pcms = 2;
3602                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3603                 info = spec->pcm_rec + 1;
3604                 info->name = spec->stream_name_digital;
3605                 if (spec->dig_out_type)
3606                         info->pcm_type = spec->dig_out_type;
3607                 else
3608                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3609                 if (spec->multiout.dig_out_nid &&
3610                     spec->stream_digital_playback) {
3611                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3612                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3613                 }
3614                 if (spec->dig_in_nid &&
3615                     spec->stream_digital_capture) {
3616                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3617                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3618                 }
3619                 /* FIXME: do we need this for all Realtek codec models? */
3620                 codec->spdif_status_reset = 1;
3621         }
3622
3623         if (spec->no_analog)
3624                 return 0;
3625
3626         /* If the use of more than one ADC is requested for the current
3627          * model, configure a second analog capture-only PCM.
3628          */
3629         /* Additional Analaog capture for index #2 */
3630         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3631             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3632                 codec->num_pcms = 3;
3633                 info = spec->pcm_rec + 2;
3634                 info->name = spec->stream_name_analog;
3635                 if (spec->alt_dac_nid) {
3636                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3637                                 *spec->stream_analog_alt_playback;
3638                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3639                                 spec->alt_dac_nid;
3640                 } else {
3641                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3642                                 alc_pcm_null_stream;
3643                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3644                 }
3645                 if (spec->num_adc_nids > 1) {
3646                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3647                                 *spec->stream_analog_alt_capture;
3648                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3649                                 spec->adc_nids[1];
3650                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3651                                 spec->num_adc_nids - 1;
3652                 } else {
3653                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3654                                 alc_pcm_null_stream;
3655                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3656                 }
3657         }
3658
3659         return 0;
3660 }
3661
3662 static void alc_free_kctls(struct hda_codec *codec)
3663 {
3664         struct alc_spec *spec = codec->spec;
3665
3666         if (spec->kctls.list) {
3667                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3668                 int i;
3669                 for (i = 0; i < spec->kctls.used; i++)
3670                         kfree(kctl[i].name);
3671         }
3672         snd_array_free(&spec->kctls);
3673 }
3674
3675 static void alc_free(struct hda_codec *codec)
3676 {
3677         struct alc_spec *spec = codec->spec;
3678
3679         if (!spec)
3680                 return;
3681
3682         alc_free_kctls(codec);
3683         kfree(spec);
3684         snd_hda_detach_beep_device(codec);
3685 }
3686
3687 #ifdef SND_HDA_NEEDS_RESUME
3688 static int alc_resume(struct hda_codec *codec)
3689 {
3690         codec->patch_ops.init(codec);
3691         snd_hda_codec_resume_amp(codec);
3692         snd_hda_codec_resume_cache(codec);
3693         return 0;
3694 }
3695 #endif
3696
3697 /*
3698  */
3699 static struct hda_codec_ops alc_patch_ops = {
3700         .build_controls = alc_build_controls,
3701         .build_pcms = alc_build_pcms,
3702         .init = alc_init,
3703         .free = alc_free,
3704         .unsol_event = alc_unsol_event,
3705 #ifdef SND_HDA_NEEDS_RESUME
3706         .resume = alc_resume,
3707 #endif
3708 #ifdef CONFIG_SND_HDA_POWER_SAVE
3709         .check_power_status = alc_check_power_status,
3710 #endif
3711 };
3712
3713
3714 /*
3715  * Test configuration for debugging
3716  *
3717  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3718  * enum controls.
3719  */
3720 #ifdef CONFIG_SND_DEBUG
3721 static hda_nid_t alc880_test_dac_nids[4] = {
3722         0x02, 0x03, 0x04, 0x05
3723 };
3724
3725 static struct hda_input_mux alc880_test_capture_source = {
3726         .num_items = 7,
3727         .items = {
3728                 { "In-1", 0x0 },
3729                 { "In-2", 0x1 },
3730                 { "In-3", 0x2 },
3731                 { "In-4", 0x3 },
3732                 { "CD", 0x4 },
3733                 { "Front", 0x5 },
3734                 { "Surround", 0x6 },
3735         },
3736 };
3737
3738 static struct hda_channel_mode alc880_test_modes[4] = {
3739         { 2, NULL },
3740         { 4, NULL },
3741         { 6, NULL },
3742         { 8, NULL },
3743 };
3744
3745 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3746                                  struct snd_ctl_elem_info *uinfo)
3747 {
3748         static char *texts[] = {
3749                 "N/A", "Line Out", "HP Out",
3750                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3751         };
3752         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3753         uinfo->count = 1;
3754         uinfo->value.enumerated.items = 8;
3755         if (uinfo->value.enumerated.item >= 8)
3756                 uinfo->value.enumerated.item = 7;
3757         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3758         return 0;
3759 }
3760
3761 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3762                                 struct snd_ctl_elem_value *ucontrol)
3763 {
3764         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3765         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3766         unsigned int pin_ctl, item = 0;
3767
3768         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3769                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3770         if (pin_ctl & AC_PINCTL_OUT_EN) {
3771                 if (pin_ctl & AC_PINCTL_HP_EN)
3772                         item = 2;
3773                 else
3774                         item = 1;
3775         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3776                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3777                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3778                 case AC_PINCTL_VREF_50:  item = 4; break;
3779                 case AC_PINCTL_VREF_GRD: item = 5; break;
3780                 case AC_PINCTL_VREF_80:  item = 6; break;
3781                 case AC_PINCTL_VREF_100: item = 7; break;
3782                 }
3783         }
3784         ucontrol->value.enumerated.item[0] = item;
3785         return 0;
3786 }
3787
3788 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3789                                 struct snd_ctl_elem_value *ucontrol)
3790 {
3791         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3792         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3793         static unsigned int ctls[] = {
3794                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3795                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3796                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3797                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3798                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3799                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3800         };
3801         unsigned int old_ctl, new_ctl;
3802
3803         old_ctl = snd_hda_codec_read(codec, nid, 0,
3804                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3805         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3806         if (old_ctl != new_ctl) {
3807                 int val;
3808                 snd_hda_codec_write_cache(codec, nid, 0,
3809                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3810                                           new_ctl);
3811                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3812                         HDA_AMP_MUTE : 0;
3813                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3814                                          HDA_AMP_MUTE, val);
3815                 return 1;
3816         }
3817         return 0;
3818 }
3819
3820 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3821                                  struct snd_ctl_elem_info *uinfo)
3822 {
3823         static char *texts[] = {
3824                 "Front", "Surround", "CLFE", "Side"
3825         };
3826         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3827         uinfo->count = 1;
3828         uinfo->value.enumerated.items = 4;
3829         if (uinfo->value.enumerated.item >= 4)
3830                 uinfo->value.enumerated.item = 3;
3831         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3832         return 0;
3833 }
3834
3835 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3836                                 struct snd_ctl_elem_value *ucontrol)
3837 {
3838         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3839         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3840         unsigned int sel;
3841
3842         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3843         ucontrol->value.enumerated.item[0] = sel & 3;
3844         return 0;
3845 }
3846
3847 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3848                                 struct snd_ctl_elem_value *ucontrol)
3849 {
3850         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3851         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3852         unsigned int sel;
3853
3854         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3855         if (ucontrol->value.enumerated.item[0] != sel) {
3856                 sel = ucontrol->value.enumerated.item[0] & 3;
3857                 snd_hda_codec_write_cache(codec, nid, 0,
3858                                           AC_VERB_SET_CONNECT_SEL, sel);
3859                 return 1;
3860         }
3861         return 0;
3862 }
3863
3864 #define PIN_CTL_TEST(xname,nid) {                       \
3865                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3866                         .name = xname,                 \
3867                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3868                         .info = alc_test_pin_ctl_info, \
3869                         .get = alc_test_pin_ctl_get,   \
3870                         .put = alc_test_pin_ctl_put,   \
3871                         .private_value = nid           \
3872                         }
3873
3874 #define PIN_SRC_TEST(xname,nid) {                       \
3875                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3876                         .name = xname,                 \
3877                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3878                         .info = alc_test_pin_src_info, \
3879                         .get = alc_test_pin_src_get,   \
3880                         .put = alc_test_pin_src_put,   \
3881                         .private_value = nid           \
3882                         }
3883
3884 static struct snd_kcontrol_new alc880_test_mixer[] = {
3885         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3886         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3887         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3888         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3889         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3890         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3891         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3892         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3893         PIN_CTL_TEST("Front Pin Mode", 0x14),
3894         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3895         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3896         PIN_CTL_TEST("Side Pin Mode", 0x17),
3897         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3898         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3899         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3900         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3901         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3902         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3903         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3904         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3905         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3906         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3907         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3908         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3909         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3910         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3911         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3912         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3913         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3914         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3915         {
3916                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3917                 .name = "Channel Mode",
3918                 .info = alc_ch_mode_info,
3919                 .get = alc_ch_mode_get,
3920                 .put = alc_ch_mode_put,
3921         },
3922         { } /* end */
3923 };
3924
3925 static struct hda_verb alc880_test_init_verbs[] = {
3926         /* Unmute inputs of 0x0c - 0x0f */
3927         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3928         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3929         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3930         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3931         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3932         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3933         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3934         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3935         /* Vol output for 0x0c-0x0f */
3936         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3937         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3938         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3939         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3940         /* Set output pins 0x14-0x17 */
3941         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3942         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3943         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3944         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3945         /* Unmute output pins 0x14-0x17 */
3946         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3947         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3948         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3949         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3950         /* Set input pins 0x18-0x1c */
3951         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3952         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3954         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3955         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3956         /* Mute input pins 0x18-0x1b */
3957         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3958         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3959         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3960         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3961         /* ADC set up */
3962         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3963         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3964         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3965         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3966         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3967         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3968         /* Analog input/passthru */
3969         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3970         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3971         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3972         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3973         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3974         { }
3975 };
3976 #endif
3977
3978 /*
3979  */
3980
3981 static const char *alc880_models[ALC880_MODEL_LAST] = {
3982         [ALC880_3ST]            = "3stack",
3983         [ALC880_TCL_S700]       = "tcl",
3984         [ALC880_3ST_DIG]        = "3stack-digout",
3985         [ALC880_CLEVO]          = "clevo",
3986         [ALC880_5ST]            = "5stack",
3987         [ALC880_5ST_DIG]        = "5stack-digout",
3988         [ALC880_W810]           = "w810",
3989         [ALC880_Z71V]           = "z71v",
3990         [ALC880_6ST]            = "6stack",
3991         [ALC880_6ST_DIG]        = "6stack-digout",
3992         [ALC880_ASUS]           = "asus",
3993         [ALC880_ASUS_W1V]       = "asus-w1v",
3994         [ALC880_ASUS_DIG]       = "asus-dig",
3995         [ALC880_ASUS_DIG2]      = "asus-dig2",
3996         [ALC880_UNIWILL_DIG]    = "uniwill",
3997         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3998         [ALC880_FUJITSU]        = "fujitsu",
3999         [ALC880_F1734]          = "F1734",
4000         [ALC880_LG]             = "lg",
4001         [ALC880_LG_LW]          = "lg-lw",
4002         [ALC880_MEDION_RIM]     = "medion",
4003 #ifdef CONFIG_SND_DEBUG
4004         [ALC880_TEST]           = "test",
4005 #endif
4006         [ALC880_AUTO]           = "auto",
4007 };
4008
4009 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4010         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4011         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4012         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4013         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4014         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4015         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4016         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4017         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4018         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4019         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4020         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4021         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4022         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4023         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4024         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4025         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4026         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4027         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4028         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4029         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4030         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4031         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4032         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4033         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4034         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4035         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4036         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4037         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4038         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4039         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4040         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4041         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4042         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4043         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4044         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4045         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4046         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4047         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4048         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4049         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4050         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4051         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4052         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4053         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4054         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4055         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4056         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4057         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4058         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4059         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4060         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4061         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4062         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4063         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4064         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4065         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4066         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4067         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4068         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4069         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4070         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4071         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4072         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4073         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4074         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4075         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4076         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4077         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4078         /* default Intel */
4079         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4080         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4081         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4082         {}
4083 };
4084
4085 /*
4086  * ALC880 codec presets
4087  */
4088 static struct alc_config_preset alc880_presets[] = {
4089         [ALC880_3ST] = {
4090                 .mixers = { alc880_three_stack_mixer },
4091                 .init_verbs = { alc880_volume_init_verbs,
4092                                 alc880_pin_3stack_init_verbs },
4093                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4094                 .dac_nids = alc880_dac_nids,
4095                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4096                 .channel_mode = alc880_threestack_modes,
4097                 .need_dac_fix = 1,
4098                 .input_mux = &alc880_capture_source,
4099         },
4100         [ALC880_3ST_DIG] = {
4101                 .mixers = { alc880_three_stack_mixer },
4102                 .init_verbs = { alc880_volume_init_verbs,
4103                                 alc880_pin_3stack_init_verbs },
4104                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4105                 .dac_nids = alc880_dac_nids,
4106                 .dig_out_nid = ALC880_DIGOUT_NID,
4107                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4108                 .channel_mode = alc880_threestack_modes,
4109                 .need_dac_fix = 1,
4110                 .input_mux = &alc880_capture_source,
4111         },
4112         [ALC880_TCL_S700] = {
4113                 .mixers = { alc880_tcl_s700_mixer },
4114                 .init_verbs = { alc880_volume_init_verbs,
4115                                 alc880_pin_tcl_S700_init_verbs,
4116                                 alc880_gpio2_init_verbs },
4117                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4118                 .dac_nids = alc880_dac_nids,
4119                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4120                 .num_adc_nids = 1, /* single ADC */
4121                 .hp_nid = 0x03,
4122                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4123                 .channel_mode = alc880_2_jack_modes,
4124                 .input_mux = &alc880_capture_source,
4125         },
4126         [ALC880_5ST] = {
4127                 .mixers = { alc880_three_stack_mixer,
4128                             alc880_five_stack_mixer},
4129                 .init_verbs = { alc880_volume_init_verbs,
4130                                 alc880_pin_5stack_init_verbs },
4131                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4132                 .dac_nids = alc880_dac_nids,
4133                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4134                 .channel_mode = alc880_fivestack_modes,
4135                 .input_mux = &alc880_capture_source,
4136         },
4137         [ALC880_5ST_DIG] = {
4138                 .mixers = { alc880_three_stack_mixer,
4139                             alc880_five_stack_mixer },
4140                 .init_verbs = { alc880_volume_init_verbs,
4141                                 alc880_pin_5stack_init_verbs },
4142                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4143                 .dac_nids = alc880_dac_nids,
4144                 .dig_out_nid = ALC880_DIGOUT_NID,
4145                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4146                 .channel_mode = alc880_fivestack_modes,
4147                 .input_mux = &alc880_capture_source,
4148         },
4149         [ALC880_6ST] = {
4150                 .mixers = { alc880_six_stack_mixer },
4151                 .init_verbs = { alc880_volume_init_verbs,
4152                                 alc880_pin_6stack_init_verbs },
4153                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4154                 .dac_nids = alc880_6st_dac_nids,
4155                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4156                 .channel_mode = alc880_sixstack_modes,
4157                 .input_mux = &alc880_6stack_capture_source,
4158         },
4159         [ALC880_6ST_DIG] = {
4160                 .mixers = { alc880_six_stack_mixer },
4161                 .init_verbs = { alc880_volume_init_verbs,
4162                                 alc880_pin_6stack_init_verbs },
4163                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4164                 .dac_nids = alc880_6st_dac_nids,
4165                 .dig_out_nid = ALC880_DIGOUT_NID,
4166                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4167                 .channel_mode = alc880_sixstack_modes,
4168                 .input_mux = &alc880_6stack_capture_source,
4169         },
4170         [ALC880_W810] = {
4171                 .mixers = { alc880_w810_base_mixer },
4172                 .init_verbs = { alc880_volume_init_verbs,
4173                                 alc880_pin_w810_init_verbs,
4174                                 alc880_gpio2_init_verbs },
4175                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4176                 .dac_nids = alc880_w810_dac_nids,
4177                 .dig_out_nid = ALC880_DIGOUT_NID,
4178                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4179                 .channel_mode = alc880_w810_modes,
4180                 .input_mux = &alc880_capture_source,
4181         },
4182         [ALC880_Z71V] = {
4183                 .mixers = { alc880_z71v_mixer },
4184                 .init_verbs = { alc880_volume_init_verbs,
4185                                 alc880_pin_z71v_init_verbs },
4186                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4187                 .dac_nids = alc880_z71v_dac_nids,
4188                 .dig_out_nid = ALC880_DIGOUT_NID,
4189                 .hp_nid = 0x03,
4190                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4191                 .channel_mode = alc880_2_jack_modes,
4192                 .input_mux = &alc880_capture_source,
4193         },
4194         [ALC880_F1734] = {
4195                 .mixers = { alc880_f1734_mixer },
4196                 .init_verbs = { alc880_volume_init_verbs,
4197                                 alc880_pin_f1734_init_verbs },
4198                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4199                 .dac_nids = alc880_f1734_dac_nids,
4200                 .hp_nid = 0x02,
4201                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4202                 .channel_mode = alc880_2_jack_modes,
4203                 .input_mux = &alc880_f1734_capture_source,
4204                 .unsol_event = alc880_uniwill_p53_unsol_event,
4205                 .setup = alc880_uniwill_p53_setup,
4206                 .init_hook = alc_automute_amp,
4207         },
4208         [ALC880_ASUS] = {
4209                 .mixers = { alc880_asus_mixer },
4210                 .init_verbs = { alc880_volume_init_verbs,
4211                                 alc880_pin_asus_init_verbs,
4212                                 alc880_gpio1_init_verbs },
4213                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4214                 .dac_nids = alc880_asus_dac_nids,
4215                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4216                 .channel_mode = alc880_asus_modes,
4217                 .need_dac_fix = 1,
4218                 .input_mux = &alc880_capture_source,
4219         },
4220         [ALC880_ASUS_DIG] = {
4221                 .mixers = { alc880_asus_mixer },
4222                 .init_verbs = { alc880_volume_init_verbs,
4223                                 alc880_pin_asus_init_verbs,
4224                                 alc880_gpio1_init_verbs },
4225                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4226                 .dac_nids = alc880_asus_dac_nids,
4227                 .dig_out_nid = ALC880_DIGOUT_NID,
4228                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4229                 .channel_mode = alc880_asus_modes,
4230                 .need_dac_fix = 1,
4231                 .input_mux = &alc880_capture_source,
4232         },
4233         [ALC880_ASUS_DIG2] = {
4234                 .mixers = { alc880_asus_mixer },
4235                 .init_verbs = { alc880_volume_init_verbs,
4236                                 alc880_pin_asus_init_verbs,
4237                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4238                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4239                 .dac_nids = alc880_asus_dac_nids,
4240                 .dig_out_nid = ALC880_DIGOUT_NID,
4241                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4242                 .channel_mode = alc880_asus_modes,
4243                 .need_dac_fix = 1,
4244                 .input_mux = &alc880_capture_source,
4245         },
4246         [ALC880_ASUS_W1V] = {
4247                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4248                 .init_verbs = { alc880_volume_init_verbs,
4249                                 alc880_pin_asus_init_verbs,
4250                                 alc880_gpio1_init_verbs },
4251                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4252                 .dac_nids = alc880_asus_dac_nids,
4253                 .dig_out_nid = ALC880_DIGOUT_NID,
4254                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4255                 .channel_mode = alc880_asus_modes,
4256                 .need_dac_fix = 1,
4257                 .input_mux = &alc880_capture_source,
4258         },
4259         [ALC880_UNIWILL_DIG] = {
4260                 .mixers = { alc880_asus_mixer },
4261                 .init_verbs = { alc880_volume_init_verbs,
4262                                 alc880_pin_asus_init_verbs },
4263                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4264                 .dac_nids = alc880_asus_dac_nids,
4265                 .dig_out_nid = ALC880_DIGOUT_NID,
4266                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4267                 .channel_mode = alc880_asus_modes,
4268                 .need_dac_fix = 1,
4269                 .input_mux = &alc880_capture_source,
4270         },
4271         [ALC880_UNIWILL] = {
4272                 .mixers = { alc880_uniwill_mixer },
4273                 .init_verbs = { alc880_volume_init_verbs,
4274                                 alc880_uniwill_init_verbs },
4275                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4276                 .dac_nids = alc880_asus_dac_nids,
4277                 .dig_out_nid = ALC880_DIGOUT_NID,
4278                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4279                 .channel_mode = alc880_threestack_modes,
4280                 .need_dac_fix = 1,
4281                 .input_mux = &alc880_capture_source,
4282                 .unsol_event = alc880_uniwill_unsol_event,
4283                 .setup = alc880_uniwill_setup,
4284                 .init_hook = alc880_uniwill_init_hook,
4285         },
4286         [ALC880_UNIWILL_P53] = {
4287                 .mixers = { alc880_uniwill_p53_mixer },
4288                 .init_verbs = { alc880_volume_init_verbs,
4289                                 alc880_uniwill_p53_init_verbs },
4290                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4291                 .dac_nids = alc880_asus_dac_nids,
4292                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4293                 .channel_mode = alc880_threestack_modes,
4294                 .input_mux = &alc880_capture_source,
4295                 .unsol_event = alc880_uniwill_p53_unsol_event,
4296                 .setup = alc880_uniwill_p53_setup,
4297                 .init_hook = alc_automute_amp,
4298         },
4299         [ALC880_FUJITSU] = {
4300                 .mixers = { alc880_fujitsu_mixer },
4301                 .init_verbs = { alc880_volume_init_verbs,
4302                                 alc880_uniwill_p53_init_verbs,
4303                                 alc880_beep_init_verbs },
4304                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4305                 .dac_nids = alc880_dac_nids,
4306                 .dig_out_nid = ALC880_DIGOUT_NID,
4307                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4308                 .channel_mode = alc880_2_jack_modes,
4309                 .input_mux = &alc880_capture_source,
4310                 .unsol_event = alc880_uniwill_p53_unsol_event,
4311                 .setup = alc880_uniwill_p53_setup,
4312                 .init_hook = alc_automute_amp,
4313         },
4314         [ALC880_CLEVO] = {
4315                 .mixers = { alc880_three_stack_mixer },
4316                 .init_verbs = { alc880_volume_init_verbs,
4317                                 alc880_pin_clevo_init_verbs },
4318                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4319                 .dac_nids = alc880_dac_nids,
4320                 .hp_nid = 0x03,
4321                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4322                 .channel_mode = alc880_threestack_modes,
4323                 .need_dac_fix = 1,
4324                 .input_mux = &alc880_capture_source,
4325         },
4326         [ALC880_LG] = {
4327                 .mixers = { alc880_lg_mixer },
4328                 .init_verbs = { alc880_volume_init_verbs,
4329                                 alc880_lg_init_verbs },
4330                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4331                 .dac_nids = alc880_lg_dac_nids,
4332                 .dig_out_nid = ALC880_DIGOUT_NID,
4333                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4334                 .channel_mode = alc880_lg_ch_modes,
4335                 .need_dac_fix = 1,
4336                 .input_mux = &alc880_lg_capture_source,
4337                 .unsol_event = alc_automute_amp_unsol_event,
4338                 .setup = alc880_lg_setup,
4339                 .init_hook = alc_automute_amp,
4340 #ifdef CONFIG_SND_HDA_POWER_SAVE
4341                 .loopbacks = alc880_lg_loopbacks,
4342 #endif
4343         },
4344         [ALC880_LG_LW] = {
4345                 .mixers = { alc880_lg_lw_mixer },
4346                 .init_verbs = { alc880_volume_init_verbs,
4347                                 alc880_lg_lw_init_verbs },
4348                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4349                 .dac_nids = alc880_dac_nids,
4350                 .dig_out_nid = ALC880_DIGOUT_NID,
4351                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4352                 .channel_mode = alc880_lg_lw_modes,
4353                 .input_mux = &alc880_lg_lw_capture_source,
4354                 .unsol_event = alc_automute_amp_unsol_event,
4355                 .setup = alc880_lg_lw_setup,
4356                 .init_hook = alc_automute_amp,
4357         },
4358         [ALC880_MEDION_RIM] = {
4359                 .mixers = { alc880_medion_rim_mixer },
4360                 .init_verbs = { alc880_volume_init_verbs,
4361                                 alc880_medion_rim_init_verbs,
4362                                 alc_gpio2_init_verbs },
4363                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4364                 .dac_nids = alc880_dac_nids,
4365                 .dig_out_nid = ALC880_DIGOUT_NID,
4366                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4367                 .channel_mode = alc880_2_jack_modes,
4368                 .input_mux = &alc880_medion_rim_capture_source,
4369                 .unsol_event = alc880_medion_rim_unsol_event,
4370                 .setup = alc880_medion_rim_setup,
4371                 .init_hook = alc880_medion_rim_automute,
4372         },
4373 #ifdef CONFIG_SND_DEBUG
4374         [ALC880_TEST] = {
4375                 .mixers = { alc880_test_mixer },
4376                 .init_verbs = { alc880_test_init_verbs },
4377                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4378                 .dac_nids = alc880_test_dac_nids,
4379                 .dig_out_nid = ALC880_DIGOUT_NID,
4380                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4381                 .channel_mode = alc880_test_modes,
4382                 .input_mux = &alc880_test_capture_source,
4383         },
4384 #endif
4385 };
4386
4387 /*
4388  * Automatic parse of I/O pins from the BIOS configuration
4389  */
4390
4391 enum {
4392         ALC_CTL_WIDGET_VOL,
4393         ALC_CTL_WIDGET_MUTE,
4394         ALC_CTL_BIND_MUTE,
4395 };
4396 static struct snd_kcontrol_new alc880_control_templates[] = {
4397         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4398         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4399         HDA_BIND_MUTE(NULL, 0, 0, 0),
4400 };
4401
4402 /* add dynamic controls */
4403 static int add_control(struct alc_spec *spec, int type, const char *name,
4404                        unsigned long val)
4405 {
4406         struct snd_kcontrol_new *knew;
4407
4408         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4409         knew = snd_array_new(&spec->kctls);
4410         if (!knew)
4411                 return -ENOMEM;
4412         *knew = alc880_control_templates[type];
4413         knew->name = kstrdup(name, GFP_KERNEL);
4414         if (!knew->name)
4415                 return -ENOMEM;
4416         if (get_amp_nid_(val))
4417                 knew->subdevice = HDA_SUBDEV_NID_FLAG |
4418                                   HDA_SUBDEV_AMP_FLAG |
4419                                   get_amp_nid_(val);
4420         knew->private_value = val;
4421         return 0;
4422 }
4423
4424 static int add_control_with_pfx(struct alc_spec *spec, int type,
4425                                 const char *pfx, const char *dir,
4426                                 const char *sfx, unsigned long val)
4427 {
4428         char name[32];
4429         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4430         return add_control(spec, type, name, val);
4431 }
4432
4433 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4434         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4435 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4436         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4437
4438 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4439 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4440 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4441 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4442 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4443 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4444 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4445 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4446 #define ALC880_PIN_CD_NID               0x1c
4447
4448 /* fill in the dac_nids table from the parsed pin configuration */
4449 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4450                                      const struct auto_pin_cfg *cfg)
4451 {
4452         hda_nid_t nid;
4453         int assigned[4];
4454         int i, j;
4455
4456         memset(assigned, 0, sizeof(assigned));
4457         spec->multiout.dac_nids = spec->private_dac_nids;
4458
4459         /* check the pins hardwired to audio widget */
4460         for (i = 0; i < cfg->line_outs; i++) {
4461                 nid = cfg->line_out_pins[i];
4462                 if (alc880_is_fixed_pin(nid)) {
4463                         int idx = alc880_fixed_pin_idx(nid);
4464                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4465                         assigned[idx] = 1;
4466                 }
4467         }
4468         /* left pins can be connect to any audio widget */
4469         for (i = 0; i < cfg->line_outs; i++) {
4470                 nid = cfg->line_out_pins[i];
4471                 if (alc880_is_fixed_pin(nid))
4472                         continue;
4473                 /* search for an empty channel */
4474                 for (j = 0; j < cfg->line_outs; j++) {
4475                         if (!assigned[j]) {
4476                                 spec->multiout.dac_nids[i] =
4477                                         alc880_idx_to_dac(j);
4478                                 assigned[j] = 1;
4479                                 break;
4480                         }
4481                 }
4482         }
4483         spec->multiout.num_dacs = cfg->line_outs;
4484         return 0;
4485 }
4486
4487 /* add playback controls from the parsed DAC table */
4488 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4489                                              const struct auto_pin_cfg *cfg)
4490 {
4491         static const char *chname[4] = {
4492                 "Front", "Surround", NULL /*CLFE*/, "Side"
4493         };
4494         hda_nid_t nid;
4495         int i, err;
4496
4497         for (i = 0; i < cfg->line_outs; i++) {
4498                 if (!spec->multiout.dac_nids[i])
4499                         continue;
4500                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4501                 if (i == 2) {
4502                         /* Center/LFE */
4503                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4504                                               "Center",
4505                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4506                                                               HDA_OUTPUT));
4507                         if (err < 0)
4508                                 return err;
4509                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4510                                               "LFE",
4511                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4512                                                               HDA_OUTPUT));
4513                         if (err < 0)
4514                                 return err;
4515                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4516                                              "Center",
4517                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4518                                                               HDA_INPUT));
4519                         if (err < 0)
4520                                 return err;
4521                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4522                                              "LFE",
4523                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4524                                                               HDA_INPUT));
4525                         if (err < 0)
4526                                 return err;
4527                 } else {
4528                         const char *pfx;
4529                         if (cfg->line_outs == 1 &&
4530                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4531                                 pfx = "Speaker";
4532                         else
4533                                 pfx = chname[i];
4534                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4535                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4536                                                               HDA_OUTPUT));
4537                         if (err < 0)
4538                                 return err;
4539                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4540                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4541                                                               HDA_INPUT));
4542                         if (err < 0)
4543                                 return err;
4544                 }
4545         }
4546         return 0;
4547 }
4548
4549 /* add playback controls for speaker and HP outputs */
4550 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4551                                         const char *pfx)
4552 {
4553         hda_nid_t nid;
4554         int err;
4555
4556         if (!pin)
4557                 return 0;
4558
4559         if (alc880_is_fixed_pin(pin)) {
4560                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4561                 /* specify the DAC as the extra output */
4562                 if (!spec->multiout.hp_nid)
4563                         spec->multiout.hp_nid = nid;
4564                 else
4565                         spec->multiout.extra_out_nid[0] = nid;
4566                 /* control HP volume/switch on the output mixer amp */
4567                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4568                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4569                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4570                 if (err < 0)
4571                         return err;
4572                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4573                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4574                 if (err < 0)
4575                         return err;
4576         } else if (alc880_is_multi_pin(pin)) {
4577                 /* set manual connection */
4578                 /* we have only a switch on HP-out PIN */
4579                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4580                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4581                 if (err < 0)
4582                         return err;
4583         }
4584         return 0;
4585 }
4586
4587 /* create input playback/capture controls for the given pin */
4588 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4589                             const char *ctlname,
4590                             int idx, hda_nid_t mix_nid)
4591 {
4592         int err;
4593
4594         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4595                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4596         if (err < 0)
4597                 return err;
4598         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4599                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4600         if (err < 0)
4601                 return err;
4602         return 0;
4603 }
4604
4605 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4606 {
4607         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4608         return (pincap & AC_PINCAP_IN) != 0;
4609 }
4610
4611 /* create playback/capture controls for input pins */
4612 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4613                                       const struct auto_pin_cfg *cfg,
4614                                       hda_nid_t mixer,
4615                                       hda_nid_t cap1, hda_nid_t cap2)
4616 {
4617         struct alc_spec *spec = codec->spec;
4618         struct hda_input_mux *imux = &spec->private_imux[0];
4619         int i, err, idx;
4620
4621         for (i = 0; i < AUTO_PIN_LAST; i++) {
4622                 hda_nid_t pin;
4623
4624                 pin = cfg->input_pins[i];
4625                 if (!alc_is_input_pin(codec, pin))
4626                         continue;
4627
4628                 if (mixer) {
4629                         idx = get_connection_index(codec, mixer, pin);
4630                         if (idx >= 0) {
4631                                 err = new_analog_input(spec, pin,
4632                                                        auto_pin_cfg_labels[i],
4633                                                        idx, mixer);
4634                                 if (err < 0)
4635                                         return err;
4636                         }
4637                 }
4638
4639                 if (!cap1)
4640                         continue;
4641                 idx = get_connection_index(codec, cap1, pin);
4642                 if (idx < 0 && cap2)
4643                         idx = get_connection_index(codec, cap2, pin);
4644                 if (idx >= 0) {
4645                         imux->items[imux->num_items].label =
4646                                 auto_pin_cfg_labels[i];
4647                         imux->items[imux->num_items].index = idx;
4648                         imux->num_items++;
4649                 }
4650         }
4651         return 0;
4652 }
4653
4654 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4655                                                 const struct auto_pin_cfg *cfg)
4656 {
4657         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4658 }
4659
4660 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4661                                unsigned int pin_type)
4662 {
4663         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4664                             pin_type);
4665         /* unmute pin */
4666         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4667                             AMP_OUT_UNMUTE);
4668 }
4669
4670 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4671                                               hda_nid_t nid, int pin_type,
4672                                               int dac_idx)
4673 {
4674         alc_set_pin_output(codec, nid, pin_type);
4675         /* need the manual connection? */
4676         if (alc880_is_multi_pin(nid)) {
4677                 struct alc_spec *spec = codec->spec;
4678                 int idx = alc880_multi_pin_idx(nid);
4679                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4680                                     AC_VERB_SET_CONNECT_SEL,
4681                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4682         }
4683 }
4684
4685 static int get_pin_type(int line_out_type)
4686 {
4687         if (line_out_type == AUTO_PIN_HP_OUT)
4688                 return PIN_HP;
4689         else
4690                 return PIN_OUT;
4691 }
4692
4693 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4694 {
4695         struct alc_spec *spec = codec->spec;
4696         int i;
4697
4698         for (i = 0; i < spec->autocfg.line_outs; i++) {
4699                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4700                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4701                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4702         }
4703 }
4704
4705 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4706 {
4707         struct alc_spec *spec = codec->spec;
4708         hda_nid_t pin;
4709
4710         pin = spec->autocfg.speaker_pins[0];
4711         if (pin) /* connect to front */
4712                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4713         pin = spec->autocfg.hp_pins[0];
4714         if (pin) /* connect to front */
4715                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4716 }
4717
4718 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4719 {
4720         struct alc_spec *spec = codec->spec;
4721         int i;
4722
4723         for (i = 0; i < AUTO_PIN_LAST; i++) {
4724                 hda_nid_t nid = spec->autocfg.input_pins[i];
4725                 if (alc_is_input_pin(codec, nid)) {
4726                         alc_set_input_pin(codec, nid, i);
4727                         if (nid != ALC880_PIN_CD_NID &&
4728                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4729                                 snd_hda_codec_write(codec, nid, 0,
4730                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4731                                                     AMP_OUT_MUTE);
4732                 }
4733         }
4734 }
4735
4736 /* parse the BIOS configuration and set up the alc_spec */
4737 /* return 1 if successful, 0 if the proper config is not found,
4738  * or a negative error code
4739  */
4740 static int alc880_parse_auto_config(struct hda_codec *codec)
4741 {
4742         struct alc_spec *spec = codec->spec;
4743         int i, err;
4744         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4745
4746         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4747                                            alc880_ignore);
4748         if (err < 0)
4749                 return err;
4750         if (!spec->autocfg.line_outs)
4751                 return 0; /* can't find valid BIOS pin config */
4752
4753         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4754         if (err < 0)
4755                 return err;
4756         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4757         if (err < 0)
4758                 return err;
4759         err = alc880_auto_create_extra_out(spec,
4760                                            spec->autocfg.speaker_pins[0],
4761                                            "Speaker");
4762         if (err < 0)
4763                 return err;
4764         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4765                                            "Headphone");
4766         if (err < 0)
4767                 return err;
4768         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4769         if (err < 0)
4770                 return err;
4771
4772         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4773
4774         /* check multiple SPDIF-out (for recent codecs) */
4775         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4776                 hda_nid_t dig_nid;
4777                 err = snd_hda_get_connections(codec,
4778                                               spec->autocfg.dig_out_pins[i],
4779                                               &dig_nid, 1);
4780                 if (err < 0)
4781                         continue;
4782                 if (!i)
4783                         spec->multiout.dig_out_nid = dig_nid;
4784                 else {
4785                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4786                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4787                                 break;
4788                         spec->slave_dig_outs[i - 1] = dig_nid;
4789                 }
4790         }
4791         if (spec->autocfg.dig_in_pin)
4792                 spec->dig_in_nid = ALC880_DIGIN_NID;
4793
4794         if (spec->kctls.list)
4795                 add_mixer(spec, spec->kctls.list);
4796
4797         add_verb(spec, alc880_volume_init_verbs);
4798
4799         spec->num_mux_defs = 1;
4800         spec->input_mux = &spec->private_imux[0];
4801
4802         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4803
4804         return 1;
4805 }
4806
4807 /* additional initialization for auto-configuration model */
4808 static void alc880_auto_init(struct hda_codec *codec)
4809 {
4810         struct alc_spec *spec = codec->spec;
4811         alc880_auto_init_multi_out(codec);
4812         alc880_auto_init_extra_out(codec);
4813         alc880_auto_init_analog_input(codec);
4814         if (spec->unsol_event)
4815                 alc_inithook(codec);
4816 }
4817
4818 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4819  * one of two digital mic pins, e.g. on ALC272
4820  */
4821 static void fixup_automic_adc(struct hda_codec *codec)
4822 {
4823         struct alc_spec *spec = codec->spec;
4824         int i;
4825
4826         for (i = 0; i < spec->num_adc_nids; i++) {
4827                 hda_nid_t cap = spec->capsrc_nids ?
4828                         spec->capsrc_nids[i] : spec->adc_nids[i];
4829                 int iidx, eidx;
4830
4831                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4832                 if (iidx < 0)
4833                         continue;
4834                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4835                 if (eidx < 0)
4836                         continue;
4837                 spec->int_mic.mux_idx = iidx;
4838                 spec->ext_mic.mux_idx = eidx;
4839                 if (spec->capsrc_nids)
4840                         spec->capsrc_nids += i;
4841                 spec->adc_nids += i;
4842                 spec->num_adc_nids = 1;
4843                 return;
4844         }
4845         snd_printd(KERN_INFO "hda_codec: %s: "
4846                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4847                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4848         spec->auto_mic = 0; /* disable auto-mic to be sure */
4849 }
4850
4851 static void set_capture_mixer(struct hda_codec *codec)
4852 {
4853         struct alc_spec *spec = codec->spec;
4854         static struct snd_kcontrol_new *caps[2][3] = {
4855                 { alc_capture_mixer_nosrc1,
4856                   alc_capture_mixer_nosrc2,
4857                   alc_capture_mixer_nosrc3 },
4858                 { alc_capture_mixer1,
4859                   alc_capture_mixer2,
4860                   alc_capture_mixer3 },
4861         };
4862         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4863                 int mux;
4864                 if (spec->auto_mic) {
4865                         mux = 0;
4866                         fixup_automic_adc(codec);
4867                 } else if (spec->input_mux && spec->input_mux->num_items > 1)
4868                         mux = 1;
4869                 else
4870                         mux = 0;
4871                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4872         }
4873 }
4874
4875 #ifdef CONFIG_SND_HDA_INPUT_BEEP
4876 #define set_beep_amp(spec, nid, idx, dir) \
4877         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4878 #else
4879 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
4880 #endif
4881
4882 /*
4883  * OK, here we have finally the patch for ALC880
4884  */
4885
4886 static int patch_alc880(struct hda_codec *codec)
4887 {
4888         struct alc_spec *spec;
4889         int board_config;
4890         int err;
4891
4892         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4893         if (spec == NULL)
4894                 return -ENOMEM;
4895
4896         codec->spec = spec;
4897
4898         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4899                                                   alc880_models,
4900                                                   alc880_cfg_tbl);
4901         if (board_config < 0) {
4902                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4903                        codec->chip_name);
4904                 board_config = ALC880_AUTO;
4905         }
4906
4907         if (board_config == ALC880_AUTO) {
4908                 /* automatic parse from the BIOS config */
4909                 err = alc880_parse_auto_config(codec);
4910                 if (err < 0) {
4911                         alc_free(codec);
4912                         return err;
4913                 } else if (!err) {
4914                         printk(KERN_INFO
4915                                "hda_codec: Cannot set up configuration "
4916                                "from BIOS.  Using 3-stack mode...\n");
4917                         board_config = ALC880_3ST;
4918                 }
4919         }
4920
4921         err = snd_hda_attach_beep_device(codec, 0x1);
4922         if (err < 0) {
4923                 alc_free(codec);
4924                 return err;
4925         }
4926
4927         if (board_config != ALC880_AUTO)
4928                 setup_preset(codec, &alc880_presets[board_config]);
4929
4930         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4931         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4932         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4933
4934         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4935         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4936
4937         if (!spec->adc_nids && spec->input_mux) {
4938                 /* check whether NID 0x07 is valid */
4939                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4940                 /* get type */
4941                 wcap = get_wcaps_type(wcap);
4942                 if (wcap != AC_WID_AUD_IN) {
4943                         spec->adc_nids = alc880_adc_nids_alt;
4944                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4945                 } else {
4946                         spec->adc_nids = alc880_adc_nids;
4947                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4948                 }
4949         }
4950         set_capture_mixer(codec);
4951         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4952
4953         spec->vmaster_nid = 0x0c;
4954
4955         codec->patch_ops = alc_patch_ops;
4956         if (board_config == ALC880_AUTO)
4957                 spec->init_hook = alc880_auto_init;
4958 #ifdef CONFIG_SND_HDA_POWER_SAVE
4959         if (!spec->loopback.amplist)
4960                 spec->loopback.amplist = alc880_loopbacks;
4961 #endif
4962         codec->proc_widget_hook = print_realtek_coef;
4963
4964         return 0;
4965 }
4966
4967
4968 /*
4969  * ALC260 support
4970  */
4971
4972 static hda_nid_t alc260_dac_nids[1] = {
4973         /* front */
4974         0x02,
4975 };
4976
4977 static hda_nid_t alc260_adc_nids[1] = {
4978         /* ADC0 */
4979         0x04,
4980 };
4981
4982 static hda_nid_t alc260_adc_nids_alt[1] = {
4983         /* ADC1 */
4984         0x05,
4985 };
4986
4987 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4988  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4989  */
4990 static hda_nid_t alc260_dual_adc_nids[2] = {
4991         /* ADC0, ADC1 */
4992         0x04, 0x05
4993 };
4994
4995 #define ALC260_DIGOUT_NID       0x03
4996 #define ALC260_DIGIN_NID        0x06
4997
4998 static struct hda_input_mux alc260_capture_source = {
4999         .num_items = 4,
5000         .items = {
5001                 { "Mic", 0x0 },
5002                 { "Front Mic", 0x1 },
5003                 { "Line", 0x2 },
5004                 { "CD", 0x4 },
5005         },
5006 };
5007
5008 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5009  * headphone jack and the internal CD lines since these are the only pins at
5010  * which audio can appear.  For flexibility, also allow the option of
5011  * recording the mixer output on the second ADC (ADC0 doesn't have a
5012  * connection to the mixer output).
5013  */
5014 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5015         {
5016                 .num_items = 3,
5017                 .items = {
5018                         { "Mic/Line", 0x0 },
5019                         { "CD", 0x4 },
5020                         { "Headphone", 0x2 },
5021                 },
5022         },
5023         {
5024                 .num_items = 4,
5025                 .items = {
5026                         { "Mic/Line", 0x0 },
5027                         { "CD", 0x4 },
5028                         { "Headphone", 0x2 },
5029                         { "Mixer", 0x5 },
5030                 },
5031         },
5032
5033 };
5034
5035 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5036  * the Fujitsu S702x, but jacks are marked differently.
5037  */
5038 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5039         {
5040                 .num_items = 4,
5041                 .items = {
5042                         { "Mic", 0x0 },
5043                         { "Line", 0x2 },
5044                         { "CD", 0x4 },
5045                         { "Headphone", 0x5 },
5046                 },
5047         },
5048         {
5049                 .num_items = 5,
5050                 .items = {
5051                         { "Mic", 0x0 },
5052                         { "Line", 0x2 },
5053                         { "CD", 0x4 },
5054                         { "Headphone", 0x6 },
5055                         { "Mixer", 0x5 },
5056                 },
5057         },
5058 };
5059
5060 /* Maxdata Favorit 100XS */
5061 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5062         {
5063                 .num_items = 2,
5064                 .items = {
5065                         { "Line/Mic", 0x0 },
5066                         { "CD", 0x4 },
5067                 },
5068         },
5069         {
5070                 .num_items = 3,
5071                 .items = {
5072                         { "Line/Mic", 0x0 },
5073                         { "CD", 0x4 },
5074                         { "Mixer", 0x5 },
5075                 },
5076         },
5077 };
5078
5079 /*
5080  * This is just place-holder, so there's something for alc_build_pcms to look
5081  * at when it calculates the maximum number of channels. ALC260 has no mixer
5082  * element which allows changing the channel mode, so the verb list is
5083  * never used.
5084  */
5085 static struct hda_channel_mode alc260_modes[1] = {
5086         { 2, NULL },
5087 };
5088
5089
5090 /* Mixer combinations
5091  *
5092  * basic: base_output + input + pc_beep + capture
5093  * HP: base_output + input + capture_alt
5094  * HP_3013: hp_3013 + input + capture
5095  * fujitsu: fujitsu + capture
5096  * acer: acer + capture
5097  */
5098
5099 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5100         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5101         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5102         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5103         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5104         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5105         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5106         { } /* end */
5107 };
5108
5109 static struct snd_kcontrol_new alc260_input_mixer[] = {
5110         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5111         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5112         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5113         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5114         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5115         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5116         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5117         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5118         { } /* end */
5119 };
5120
5121 /* update HP, line and mono out pins according to the master switch */
5122 static void alc260_hp_master_update(struct hda_codec *codec,
5123                                     hda_nid_t hp, hda_nid_t line,
5124                                     hda_nid_t mono)
5125 {
5126         struct alc_spec *spec = codec->spec;
5127         unsigned int val = spec->master_sw ? PIN_HP : 0;
5128         /* change HP and line-out pins */
5129         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5130                             val);
5131         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5132                             val);
5133         /* mono (speaker) depending on the HP jack sense */
5134         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5135         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5136                             val);
5137 }
5138
5139 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5140                                    struct snd_ctl_elem_value *ucontrol)
5141 {
5142         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5143         struct alc_spec *spec = codec->spec;
5144         *ucontrol->value.integer.value = spec->master_sw;
5145         return 0;
5146 }
5147
5148 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5149                                    struct snd_ctl_elem_value *ucontrol)
5150 {
5151         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5152         struct alc_spec *spec = codec->spec;
5153         int val = !!*ucontrol->value.integer.value;
5154         hda_nid_t hp, line, mono;
5155
5156         if (val == spec->master_sw)
5157                 return 0;
5158         spec->master_sw = val;
5159         hp = (kcontrol->private_value >> 16) & 0xff;
5160         line = (kcontrol->private_value >> 8) & 0xff;
5161         mono = kcontrol->private_value & 0xff;
5162         alc260_hp_master_update(codec, hp, line, mono);
5163         return 1;
5164 }
5165
5166 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5167         {
5168                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5169                 .name = "Master Playback Switch",
5170                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5171                 .info = snd_ctl_boolean_mono_info,
5172                 .get = alc260_hp_master_sw_get,
5173                 .put = alc260_hp_master_sw_put,
5174                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5175         },
5176         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5177         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5178         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5179         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5180         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5181                               HDA_OUTPUT),
5182         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5183         { } /* end */
5184 };
5185
5186 static struct hda_verb alc260_hp_unsol_verbs[] = {
5187         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5188         {},
5189 };
5190
5191 static void alc260_hp_automute(struct hda_codec *codec)
5192 {
5193         struct alc_spec *spec = codec->spec;
5194
5195         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5196         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5197 }
5198
5199 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5200 {
5201         if ((res >> 26) == ALC880_HP_EVENT)
5202                 alc260_hp_automute(codec);
5203 }
5204
5205 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5206         {
5207                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5208                 .name = "Master Playback Switch",
5209                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5210                 .info = snd_ctl_boolean_mono_info,
5211                 .get = alc260_hp_master_sw_get,
5212                 .put = alc260_hp_master_sw_put,
5213                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5214         },
5215         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5216         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5217         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5218         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5219         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5220         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5221         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5222         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5223         { } /* end */
5224 };
5225
5226 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5227         .ops = &snd_hda_bind_vol,
5228         .values = {
5229                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5230                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5231                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5232                 0
5233         },
5234 };
5235
5236 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5237         .ops = &snd_hda_bind_sw,
5238         .values = {
5239                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5240                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5241                 0
5242         },
5243 };
5244
5245 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5246         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5247         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5248         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5249         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5250         { } /* end */
5251 };
5252
5253 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5254         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5255         {},
5256 };
5257
5258 static void alc260_hp_3013_automute(struct hda_codec *codec)
5259 {
5260         struct alc_spec *spec = codec->spec;
5261
5262         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5263         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5264 }
5265
5266 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5267                                        unsigned int res)
5268 {
5269         if ((res >> 26) == ALC880_HP_EVENT)
5270                 alc260_hp_3013_automute(codec);
5271 }
5272
5273 static void alc260_hp_3012_automute(struct hda_codec *codec)
5274 {
5275         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5276
5277         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5278                             bits);
5279         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5280                             bits);
5281         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5282                             bits);
5283 }
5284
5285 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5286                                        unsigned int res)
5287 {
5288         if ((res >> 26) == ALC880_HP_EVENT)
5289                 alc260_hp_3012_automute(codec);
5290 }
5291
5292 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5293  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5294  */
5295 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5296         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5297         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5298         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5299         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5300         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5301         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5302         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5303         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5304         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5305         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5306         { } /* end */
5307 };
5308
5309 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5310  * versions of the ALC260 don't act on requests to enable mic bias from NID
5311  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5312  * datasheet doesn't mention this restriction.  At this stage it's not clear
5313  * whether this behaviour is intentional or is a hardware bug in chip
5314  * revisions available in early 2006.  Therefore for now allow the
5315  * "Headphone Jack Mode" control to span all choices, but if it turns out
5316  * that the lack of mic bias for this NID is intentional we could change the
5317  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5318  *
5319  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5320  * don't appear to make the mic bias available from the "line" jack, even
5321  * though the NID used for this jack (0x14) can supply it.  The theory is
5322  * that perhaps Acer have included blocking capacitors between the ALC260
5323  * and the output jack.  If this turns out to be the case for all such
5324  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5325  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5326  *
5327  * The C20x Tablet series have a mono internal speaker which is controlled
5328  * via the chip's Mono sum widget and pin complex, so include the necessary
5329  * controls for such models.  On models without a "mono speaker" the control
5330  * won't do anything.
5331  */
5332 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5333         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5334         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5335         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5336         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5337                               HDA_OUTPUT),
5338         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5339                            HDA_INPUT),
5340         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5341         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5342         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5343         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5344         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5345         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5346         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5347         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5348         { } /* end */
5349 };
5350
5351 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5352  */
5353 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5354         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5355         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5356         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5357         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5358         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5359         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5360         { } /* end */
5361 };
5362
5363 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5364  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5365  */
5366 static struct snd_kcontrol_new alc260_will_mixer[] = {
5367         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5368         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5369         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5370         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5371         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5372         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5373         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5374         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5375         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5376         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5377         { } /* end */
5378 };
5379
5380 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5381  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5382  */
5383 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5384         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5385         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5386         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5387         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5388         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5389         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5390         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5391         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5392         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5393         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5394         { } /* end */
5395 };
5396
5397 /*
5398  * initialization verbs
5399  */
5400 static struct hda_verb alc260_init_verbs[] = {
5401         /* Line In pin widget for input */
5402         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5403         /* CD pin widget for input */
5404         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5405         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5406         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5407         /* Mic2 (front panel) pin widget for input and vref at 80% */
5408         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5409         /* LINE-2 is used for line-out in rear */
5410         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5411         /* select line-out */
5412         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5413         /* LINE-OUT pin */
5414         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5415         /* enable HP */
5416         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5417         /* enable Mono */
5418         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5419         /* mute capture amp left and right */
5420         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5421         /* set connection select to line in (default select for this ADC) */
5422         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5423         /* mute capture amp left and right */
5424         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5425         /* set connection select to line in (default select for this ADC) */
5426         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5427         /* set vol=0 Line-Out mixer amp left and right */
5428         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5429         /* unmute pin widget amp left and right (no gain on this amp) */
5430         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5431         /* set vol=0 HP mixer amp left and right */
5432         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5433         /* unmute pin widget amp left and right (no gain on this amp) */
5434         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5435         /* set vol=0 Mono mixer amp left and right */
5436         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5437         /* unmute pin widget amp left and right (no gain on this amp) */
5438         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5439         /* unmute LINE-2 out pin */
5440         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5441         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5442          * Line In 2 = 0x03
5443          */
5444         /* mute analog inputs */
5445         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5446         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5447         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5448         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5449         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5450         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5451         /* mute Front out path */
5452         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5453         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5454         /* mute Headphone out path */
5455         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5456         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5457         /* mute Mono out path */
5458         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5459         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5460         { }
5461 };
5462
5463 #if 0 /* should be identical with alc260_init_verbs? */
5464 static struct hda_verb alc260_hp_init_verbs[] = {
5465         /* Headphone and output */
5466         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5467         /* mono output */
5468         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5469         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5470         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5471         /* Mic2 (front panel) pin widget for input and vref at 80% */
5472         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5473         /* Line In pin widget for input */
5474         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5475         /* Line-2 pin widget for output */
5476         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5477         /* CD pin widget for input */
5478         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5479         /* unmute amp left and right */
5480         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5481         /* set connection select to line in (default select for this ADC) */
5482         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5483         /* unmute Line-Out mixer amp left and right (volume = 0) */
5484         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5485         /* mute pin widget amp left and right (no gain on this amp) */
5486         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5487         /* unmute HP mixer amp left and right (volume = 0) */
5488         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5489         /* mute pin widget amp left and right (no gain on this amp) */
5490         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5491         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5492          * Line In 2 = 0x03
5493          */
5494         /* mute analog inputs */
5495         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5496         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5497         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5498         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5499         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5500         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5501         /* Unmute Front out path */
5502         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5503         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5504         /* Unmute Headphone out path */
5505         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5506         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5507         /* Unmute Mono out path */
5508         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5509         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5510         { }
5511 };
5512 #endif
5513
5514 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5515         /* Line out and output */
5516         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5517         /* mono output */
5518         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5519         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5520         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5521         /* Mic2 (front panel) pin widget for input and vref at 80% */
5522         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5523         /* Line In pin widget for input */
5524         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5525         /* Headphone pin widget for output */
5526         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5527         /* CD pin widget for input */
5528         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5529         /* unmute amp left and right */
5530         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5531         /* set connection select to line in (default select for this ADC) */
5532         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5533         /* unmute Line-Out mixer amp left and right (volume = 0) */
5534         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5535         /* mute pin widget amp left and right (no gain on this amp) */
5536         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5537         /* unmute HP mixer amp left and right (volume = 0) */
5538         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5539         /* mute pin widget amp left and right (no gain on this amp) */
5540         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5541         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5542          * Line In 2 = 0x03
5543          */
5544         /* mute analog inputs */
5545         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5546         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5547         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5548         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5549         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5550         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5551         /* Unmute Front out path */
5552         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5553         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5554         /* Unmute Headphone out path */
5555         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5556         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5557         /* Unmute Mono out path */
5558         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5559         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5560         { }
5561 };
5562
5563 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5564  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5565  * audio = 0x16, internal speaker = 0x10.
5566  */
5567 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5568         /* Disable all GPIOs */
5569         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5570         /* Internal speaker is connected to headphone pin */
5571         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5572         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5573         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5574         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5575         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5576         /* Ensure all other unused pins are disabled and muted. */
5577         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5578         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5579         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5580         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5581         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5582         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5583         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5584         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5585
5586         /* Disable digital (SPDIF) pins */
5587         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5588         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5589
5590         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5591          * when acting as an output.
5592          */
5593         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5594
5595         /* Start with output sum widgets muted and their output gains at min */
5596         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5597         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5598         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5599         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5600         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5601         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5602         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5603         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5604         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5605
5606         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5607         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5608         /* Unmute Line1 pin widget output buffer since it starts as an output.
5609          * If the pin mode is changed by the user the pin mode control will
5610          * take care of enabling the pin's input/output buffers as needed.
5611          * Therefore there's no need to enable the input buffer at this
5612          * stage.
5613          */
5614         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5615         /* Unmute input buffer of pin widget used for Line-in (no equiv
5616          * mixer ctrl)
5617          */
5618         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5619
5620         /* Mute capture amp left and right */
5621         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5622         /* Set ADC connection select to match default mixer setting - line
5623          * in (on mic1 pin)
5624          */
5625         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5626
5627         /* Do the same for the second ADC: mute capture input amp and
5628          * set ADC connection to line in (on mic1 pin)
5629          */
5630         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5631         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5632
5633         /* Mute all inputs to mixer widget (even unconnected ones) */
5634         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5635         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5636         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5637         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5638         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5639         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5640         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5641         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5642
5643         { }
5644 };
5645
5646 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5647  * similar laptops (adapted from Fujitsu init verbs).
5648  */
5649 static struct hda_verb alc260_acer_init_verbs[] = {
5650         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5651          * the headphone jack.  Turn this on and rely on the standard mute
5652          * methods whenever the user wants to turn these outputs off.
5653          */
5654         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5655         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5656         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5657         /* Internal speaker/Headphone jack is connected to Line-out pin */
5658         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5659         /* Internal microphone/Mic jack is connected to Mic1 pin */
5660         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5661         /* Line In jack is connected to Line1 pin */
5662         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5663         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5664         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5665         /* Ensure all other unused pins are disabled and muted. */
5666         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5667         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5668         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5669         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5671         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5672         /* Disable digital (SPDIF) pins */
5673         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5674         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5675
5676         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5677          * bus when acting as outputs.
5678          */
5679         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5680         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5681
5682         /* Start with output sum widgets muted and their output gains at min */
5683         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5684         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5686         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5687         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5688         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5689         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5690         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5691         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5692
5693         /* Unmute Line-out pin widget amp left and right
5694          * (no equiv mixer ctrl)
5695          */
5696         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5697         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5698         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5699         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5700          * inputs. If the pin mode is changed by the user the pin mode control
5701          * will take care of enabling the pin's input/output buffers as needed.
5702          * Therefore there's no need to enable the input buffer at this
5703          * stage.
5704          */
5705         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5706         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5707
5708         /* Mute capture amp left and right */
5709         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5710         /* Set ADC connection select to match default mixer setting - mic
5711          * (on mic1 pin)
5712          */
5713         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5714
5715         /* Do similar with the second ADC: mute capture input amp and
5716          * set ADC connection to mic to match ALSA's default state.
5717          */
5718         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5719         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5720
5721         /* Mute all inputs to mixer widget (even unconnected ones) */
5722         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5723         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5724         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5725         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5727         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5728         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5729         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5730
5731         { }
5732 };
5733
5734 /* Initialisation sequence for Maxdata Favorit 100XS
5735  * (adapted from Acer init verbs).
5736  */
5737 static struct hda_verb alc260_favorit100_init_verbs[] = {
5738         /* GPIO 0 enables the output jack.
5739          * Turn this on and rely on the standard mute
5740          * methods whenever the user wants to turn these outputs off.
5741          */
5742         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5743         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5744         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5745         /* Line/Mic input jack is connected to Mic1 pin */
5746         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5747         /* Ensure all other unused pins are disabled and muted. */
5748         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5749         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5750         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5751         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5752         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5753         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5754         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5755         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5756         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5757         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5758         /* Disable digital (SPDIF) pins */
5759         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5760         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5761
5762         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5763          * bus when acting as outputs.
5764          */
5765         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5766         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5767
5768         /* Start with output sum widgets muted and their output gains at min */
5769         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5770         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5771         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5772         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5773         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5774         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5775         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5776         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5777         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5778
5779         /* Unmute Line-out pin widget amp left and right
5780          * (no equiv mixer ctrl)
5781          */
5782         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5783         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5784          * inputs. If the pin mode is changed by the user the pin mode control
5785          * will take care of enabling the pin's input/output buffers as needed.
5786          * Therefore there's no need to enable the input buffer at this
5787          * stage.
5788          */
5789         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5790
5791         /* Mute capture amp left and right */
5792         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5793         /* Set ADC connection select to match default mixer setting - mic
5794          * (on mic1 pin)
5795          */
5796         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5797
5798         /* Do similar with the second ADC: mute capture input amp and
5799          * set ADC connection to mic to match ALSA's default state.
5800          */
5801         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5802         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5803
5804         /* Mute all inputs to mixer widget (even unconnected ones) */
5805         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5806         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5807         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5808         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5809         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5810         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5811         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5812         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5813
5814         { }
5815 };
5816
5817 static struct hda_verb alc260_will_verbs[] = {
5818         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5819         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5820         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5821         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5822         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5823         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5824         {}
5825 };
5826
5827 static struct hda_verb alc260_replacer_672v_verbs[] = {
5828         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5829         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5830         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5831
5832         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5833         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5834         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5835
5836         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5837         {}
5838 };
5839
5840 /* toggle speaker-output according to the hp-jack state */
5841 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5842 {
5843         unsigned int present;
5844
5845         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5846         present = snd_hda_jack_detect(codec, 0x0f);
5847         if (present) {
5848                 snd_hda_codec_write_cache(codec, 0x01, 0,
5849                                           AC_VERB_SET_GPIO_DATA, 1);
5850                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5851                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5852                                           PIN_HP);
5853         } else {
5854                 snd_hda_codec_write_cache(codec, 0x01, 0,
5855                                           AC_VERB_SET_GPIO_DATA, 0);
5856                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5857                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5858                                           PIN_OUT);
5859         }
5860 }
5861
5862 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5863                                        unsigned int res)
5864 {
5865         if ((res >> 26) == ALC880_HP_EVENT)
5866                 alc260_replacer_672v_automute(codec);
5867 }
5868
5869 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5870         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5871         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5872         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5873         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5874         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5875         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5876         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5877         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5878         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5879         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5880         {}
5881 };
5882
5883 /* Test configuration for debugging, modelled after the ALC880 test
5884  * configuration.
5885  */
5886 #ifdef CONFIG_SND_DEBUG
5887 static hda_nid_t alc260_test_dac_nids[1] = {
5888         0x02,
5889 };
5890 static hda_nid_t alc260_test_adc_nids[2] = {
5891         0x04, 0x05,
5892 };
5893 /* For testing the ALC260, each input MUX needs its own definition since
5894  * the signal assignments are different.  This assumes that the first ADC
5895  * is NID 0x04.
5896  */
5897 static struct hda_input_mux alc260_test_capture_sources[2] = {
5898         {
5899                 .num_items = 7,
5900                 .items = {
5901                         { "MIC1 pin", 0x0 },
5902                         { "MIC2 pin", 0x1 },
5903                         { "LINE1 pin", 0x2 },
5904                         { "LINE2 pin", 0x3 },
5905                         { "CD pin", 0x4 },
5906                         { "LINE-OUT pin", 0x5 },
5907                         { "HP-OUT pin", 0x6 },
5908                 },
5909         },
5910         {
5911                 .num_items = 8,
5912                 .items = {
5913                         { "MIC1 pin", 0x0 },
5914                         { "MIC2 pin", 0x1 },
5915                         { "LINE1 pin", 0x2 },
5916                         { "LINE2 pin", 0x3 },
5917                         { "CD pin", 0x4 },
5918                         { "Mixer", 0x5 },
5919                         { "LINE-OUT pin", 0x6 },
5920                         { "HP-OUT pin", 0x7 },
5921                 },
5922         },
5923 };
5924 static struct snd_kcontrol_new alc260_test_mixer[] = {
5925         /* Output driver widgets */
5926         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5927         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5928         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5929         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5930         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5931         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5932
5933         /* Modes for retasking pin widgets
5934          * Note: the ALC260 doesn't seem to act on requests to enable mic
5935          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5936          * mention this restriction.  At this stage it's not clear whether
5937          * this behaviour is intentional or is a hardware bug in chip
5938          * revisions available at least up until early 2006.  Therefore for
5939          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5940          * choices, but if it turns out that the lack of mic bias for these
5941          * NIDs is intentional we could change their modes from
5942          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5943          */
5944         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5945         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5946         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5947         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5948         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5949         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5950
5951         /* Loopback mixer controls */
5952         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5953         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5954         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5955         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5956         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5957         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5958         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5959         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5960         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5961         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5962         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5963         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5964         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5965         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5966
5967         /* Controls for GPIO pins, assuming they are configured as outputs */
5968         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5969         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5970         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5971         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5972
5973         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5974          * is ambigious as to which NID is which; testing on laptops which
5975          * make this output available should provide clarification.
5976          */
5977         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5978         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5979
5980         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5981          * this output to turn on an external amplifier.
5982          */
5983         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5984         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5985
5986         { } /* end */
5987 };
5988 static struct hda_verb alc260_test_init_verbs[] = {
5989         /* Enable all GPIOs as outputs with an initial value of 0 */
5990         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5991         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5992         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5993
5994         /* Enable retasking pins as output, initially without power amp */
5995         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5996         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5997         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5998         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5999         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6000         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6001
6002         /* Disable digital (SPDIF) pins initially, but users can enable
6003          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6004          * payload also sets the generation to 0, output to be in "consumer"
6005          * PCM format, copyright asserted, no pre-emphasis and no validity
6006          * control.
6007          */
6008         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6009         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6010
6011         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6012          * OUT1 sum bus when acting as an output.
6013          */
6014         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6015         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6016         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6017         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6018
6019         /* Start with output sum widgets muted and their output gains at min */
6020         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6021         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6022         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6023         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6024         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6025         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6026         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6027         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6028         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6029
6030         /* Unmute retasking pin widget output buffers since the default
6031          * state appears to be output.  As the pin mode is changed by the
6032          * user the pin mode control will take care of enabling the pin's
6033          * input/output buffers as needed.
6034          */
6035         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6036         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6037         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6038         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6039         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6040         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6041         /* Also unmute the mono-out pin widget */
6042         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6043
6044         /* Mute capture amp left and right */
6045         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6046         /* Set ADC connection select to match default mixer setting (mic1
6047          * pin)
6048          */
6049         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6050
6051         /* Do the same for the second ADC: mute capture input amp and
6052          * set ADC connection to mic1 pin
6053          */
6054         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6055         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6056
6057         /* Mute all inputs to mixer widget (even unconnected ones) */
6058         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6059         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6060         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6061         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6062         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6063         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6064         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6065         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6066
6067         { }
6068 };
6069 #endif
6070
6071 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6072 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6073
6074 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6075 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6076
6077 /*
6078  * for BIOS auto-configuration
6079  */
6080
6081 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6082                                         const char *pfx, int *vol_bits)
6083 {
6084         hda_nid_t nid_vol;
6085         unsigned long vol_val, sw_val;
6086         int err;
6087
6088         if (nid >= 0x0f && nid < 0x11) {
6089                 nid_vol = nid - 0x7;
6090                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6091                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6092         } else if (nid == 0x11) {
6093                 nid_vol = nid - 0x7;
6094                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6095                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6096         } else if (nid >= 0x12 && nid <= 0x15) {
6097                 nid_vol = 0x08;
6098                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6099                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6100         } else
6101                 return 0; /* N/A */
6102
6103         if (!(*vol_bits & (1 << nid_vol))) {
6104                 /* first control for the volume widget */
6105                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6106                 if (err < 0)
6107                         return err;
6108                 *vol_bits |= (1 << nid_vol);
6109         }
6110         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6111         if (err < 0)
6112                 return err;
6113         return 1;
6114 }
6115
6116 /* add playback controls from the parsed DAC table */
6117 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6118                                              const struct auto_pin_cfg *cfg)
6119 {
6120         hda_nid_t nid;
6121         int err;
6122         int vols = 0;
6123
6124         spec->multiout.num_dacs = 1;
6125         spec->multiout.dac_nids = spec->private_dac_nids;
6126         spec->multiout.dac_nids[0] = 0x02;
6127
6128         nid = cfg->line_out_pins[0];
6129         if (nid) {
6130                 const char *pfx;
6131                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6132                         pfx = "Master";
6133                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6134                         pfx = "Speaker";
6135                 else
6136                         pfx = "Front";
6137                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6138                 if (err < 0)
6139                         return err;
6140         }
6141
6142         nid = cfg->speaker_pins[0];
6143         if (nid) {
6144                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6145                 if (err < 0)
6146                         return err;
6147         }
6148
6149         nid = cfg->hp_pins[0];
6150         if (nid) {
6151                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6152                                                    &vols);
6153                 if (err < 0)
6154                         return err;
6155         }
6156         return 0;
6157 }
6158
6159 /* create playback/capture controls for input pins */
6160 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6161                                                 const struct auto_pin_cfg *cfg)
6162 {
6163         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6164 }
6165
6166 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6167                                               hda_nid_t nid, int pin_type,
6168                                               int sel_idx)
6169 {
6170         alc_set_pin_output(codec, nid, pin_type);
6171         /* need the manual connection? */
6172         if (nid >= 0x12) {
6173                 int idx = nid - 0x12;
6174                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6175                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6176         }
6177 }
6178
6179 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6180 {
6181         struct alc_spec *spec = codec->spec;
6182         hda_nid_t nid;
6183
6184         nid = spec->autocfg.line_out_pins[0];
6185         if (nid) {
6186                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6187                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6188         }
6189
6190         nid = spec->autocfg.speaker_pins[0];
6191         if (nid)
6192                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6193
6194         nid = spec->autocfg.hp_pins[0];
6195         if (nid)
6196                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6197 }
6198
6199 #define ALC260_PIN_CD_NID               0x16
6200 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6201 {
6202         struct alc_spec *spec = codec->spec;
6203         int i;
6204
6205         for (i = 0; i < AUTO_PIN_LAST; i++) {
6206                 hda_nid_t nid = spec->autocfg.input_pins[i];
6207                 if (nid >= 0x12) {
6208                         alc_set_input_pin(codec, nid, i);
6209                         if (nid != ALC260_PIN_CD_NID &&
6210                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6211                                 snd_hda_codec_write(codec, nid, 0,
6212                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6213                                                     AMP_OUT_MUTE);
6214                 }
6215         }
6216 }
6217
6218 /*
6219  * generic initialization of ADC, input mixers and output mixers
6220  */
6221 static struct hda_verb alc260_volume_init_verbs[] = {
6222         /*
6223          * Unmute ADC0-1 and set the default input to mic-in
6224          */
6225         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6226         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6227         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6228         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6229
6230         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6231          * mixer widget
6232          * Note: PASD motherboards uses the Line In 2 as the input for
6233          * front panel mic (mic 2)
6234          */
6235         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6236         /* mute analog inputs */
6237         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6239         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6240         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6242
6243         /*
6244          * Set up output mixers (0x08 - 0x0a)
6245          */
6246         /* set vol=0 to output mixers */
6247         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6248         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6249         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6250         /* set up input amps for analog loopback */
6251         /* Amp Indices: DAC = 0, mixer = 1 */
6252         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6253         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6254         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6255         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6256         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6257         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6258
6259         { }
6260 };
6261
6262 static int alc260_parse_auto_config(struct hda_codec *codec)
6263 {
6264         struct alc_spec *spec = codec->spec;
6265         int err;
6266         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6267
6268         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6269                                            alc260_ignore);
6270         if (err < 0)
6271                 return err;
6272         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6273         if (err < 0)
6274                 return err;
6275         if (!spec->kctls.list)
6276                 return 0; /* can't find valid BIOS pin config */
6277         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6278         if (err < 0)
6279                 return err;
6280
6281         spec->multiout.max_channels = 2;
6282
6283         if (spec->autocfg.dig_outs)
6284                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6285         if (spec->kctls.list)
6286                 add_mixer(spec, spec->kctls.list);
6287
6288         add_verb(spec, alc260_volume_init_verbs);
6289
6290         spec->num_mux_defs = 1;
6291         spec->input_mux = &spec->private_imux[0];
6292
6293         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6294
6295         return 1;
6296 }
6297
6298 /* additional initialization for auto-configuration model */
6299 static void alc260_auto_init(struct hda_codec *codec)
6300 {
6301         struct alc_spec *spec = codec->spec;
6302         alc260_auto_init_multi_out(codec);
6303         alc260_auto_init_analog_input(codec);
6304         if (spec->unsol_event)
6305                 alc_inithook(codec);
6306 }
6307
6308 #ifdef CONFIG_SND_HDA_POWER_SAVE
6309 static struct hda_amp_list alc260_loopbacks[] = {
6310         { 0x07, HDA_INPUT, 0 },
6311         { 0x07, HDA_INPUT, 1 },
6312         { 0x07, HDA_INPUT, 2 },
6313         { 0x07, HDA_INPUT, 3 },
6314         { 0x07, HDA_INPUT, 4 },
6315         { } /* end */
6316 };
6317 #endif
6318
6319 /*
6320  * ALC260 configurations
6321  */
6322 static const char *alc260_models[ALC260_MODEL_LAST] = {
6323         [ALC260_BASIC]          = "basic",
6324         [ALC260_HP]             = "hp",
6325         [ALC260_HP_3013]        = "hp-3013",
6326         [ALC260_HP_DC7600]      = "hp-dc7600",
6327         [ALC260_FUJITSU_S702X]  = "fujitsu",
6328         [ALC260_ACER]           = "acer",
6329         [ALC260_WILL]           = "will",
6330         [ALC260_REPLACER_672V]  = "replacer",
6331         [ALC260_FAVORIT100]     = "favorit100",
6332 #ifdef CONFIG_SND_DEBUG
6333         [ALC260_TEST]           = "test",
6334 #endif
6335         [ALC260_AUTO]           = "auto",
6336 };
6337
6338 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6339         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6340         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6341         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6342         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6343         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6344         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6345         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6346         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6347         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6348         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6349         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6350         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6351         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6352         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6353         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6354         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6355         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6356         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6357         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6358         {}
6359 };
6360
6361 static struct alc_config_preset alc260_presets[] = {
6362         [ALC260_BASIC] = {
6363                 .mixers = { alc260_base_output_mixer,
6364                             alc260_input_mixer },
6365                 .init_verbs = { alc260_init_verbs },
6366                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6367                 .dac_nids = alc260_dac_nids,
6368                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6369                 .adc_nids = alc260_adc_nids,
6370                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6371                 .channel_mode = alc260_modes,
6372                 .input_mux = &alc260_capture_source,
6373         },
6374         [ALC260_HP] = {
6375                 .mixers = { alc260_hp_output_mixer,
6376                             alc260_input_mixer },
6377                 .init_verbs = { alc260_init_verbs,
6378                                 alc260_hp_unsol_verbs },
6379                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6380                 .dac_nids = alc260_dac_nids,
6381                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6382                 .adc_nids = alc260_adc_nids_alt,
6383                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6384                 .channel_mode = alc260_modes,
6385                 .input_mux = &alc260_capture_source,
6386                 .unsol_event = alc260_hp_unsol_event,
6387                 .init_hook = alc260_hp_automute,
6388         },
6389         [ALC260_HP_DC7600] = {
6390                 .mixers = { alc260_hp_dc7600_mixer,
6391                             alc260_input_mixer },
6392                 .init_verbs = { alc260_init_verbs,
6393                                 alc260_hp_dc7600_verbs },
6394                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6395                 .dac_nids = alc260_dac_nids,
6396                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6397                 .adc_nids = alc260_adc_nids_alt,
6398                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6399                 .channel_mode = alc260_modes,
6400                 .input_mux = &alc260_capture_source,
6401                 .unsol_event = alc260_hp_3012_unsol_event,
6402                 .init_hook = alc260_hp_3012_automute,
6403         },
6404         [ALC260_HP_3013] = {
6405                 .mixers = { alc260_hp_3013_mixer,
6406                             alc260_input_mixer },
6407                 .init_verbs = { alc260_hp_3013_init_verbs,
6408                                 alc260_hp_3013_unsol_verbs },
6409                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6410                 .dac_nids = alc260_dac_nids,
6411                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6412                 .adc_nids = alc260_adc_nids_alt,
6413                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6414                 .channel_mode = alc260_modes,
6415                 .input_mux = &alc260_capture_source,
6416                 .unsol_event = alc260_hp_3013_unsol_event,
6417                 .init_hook = alc260_hp_3013_automute,
6418         },
6419         [ALC260_FUJITSU_S702X] = {
6420                 .mixers = { alc260_fujitsu_mixer },
6421                 .init_verbs = { alc260_fujitsu_init_verbs },
6422                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6423                 .dac_nids = alc260_dac_nids,
6424                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6425                 .adc_nids = alc260_dual_adc_nids,
6426                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6427                 .channel_mode = alc260_modes,
6428                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6429                 .input_mux = alc260_fujitsu_capture_sources,
6430         },
6431         [ALC260_ACER] = {
6432                 .mixers = { alc260_acer_mixer },
6433                 .init_verbs = { alc260_acer_init_verbs },
6434                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6435                 .dac_nids = alc260_dac_nids,
6436                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6437                 .adc_nids = alc260_dual_adc_nids,
6438                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6439                 .channel_mode = alc260_modes,
6440                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6441                 .input_mux = alc260_acer_capture_sources,
6442         },
6443         [ALC260_FAVORIT100] = {
6444                 .mixers = { alc260_favorit100_mixer },
6445                 .init_verbs = { alc260_favorit100_init_verbs },
6446                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6447                 .dac_nids = alc260_dac_nids,
6448                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6449                 .adc_nids = alc260_dual_adc_nids,
6450                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6451                 .channel_mode = alc260_modes,
6452                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6453                 .input_mux = alc260_favorit100_capture_sources,
6454         },
6455         [ALC260_WILL] = {
6456                 .mixers = { alc260_will_mixer },
6457                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6458                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6459                 .dac_nids = alc260_dac_nids,
6460                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6461                 .adc_nids = alc260_adc_nids,
6462                 .dig_out_nid = ALC260_DIGOUT_NID,
6463                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6464                 .channel_mode = alc260_modes,
6465                 .input_mux = &alc260_capture_source,
6466         },
6467         [ALC260_REPLACER_672V] = {
6468                 .mixers = { alc260_replacer_672v_mixer },
6469                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6470                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6471                 .dac_nids = alc260_dac_nids,
6472                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6473                 .adc_nids = alc260_adc_nids,
6474                 .dig_out_nid = ALC260_DIGOUT_NID,
6475                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6476                 .channel_mode = alc260_modes,
6477                 .input_mux = &alc260_capture_source,
6478                 .unsol_event = alc260_replacer_672v_unsol_event,
6479                 .init_hook = alc260_replacer_672v_automute,
6480         },
6481 #ifdef CONFIG_SND_DEBUG
6482         [ALC260_TEST] = {
6483                 .mixers = { alc260_test_mixer },
6484                 .init_verbs = { alc260_test_init_verbs },
6485                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6486                 .dac_nids = alc260_test_dac_nids,
6487                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6488                 .adc_nids = alc260_test_adc_nids,
6489                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6490                 .channel_mode = alc260_modes,
6491                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6492                 .input_mux = alc260_test_capture_sources,
6493         },
6494 #endif
6495 };
6496
6497 static int patch_alc260(struct hda_codec *codec)
6498 {
6499         struct alc_spec *spec;
6500         int err, board_config;
6501
6502         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6503         if (spec == NULL)
6504                 return -ENOMEM;
6505
6506         codec->spec = spec;
6507
6508         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6509                                                   alc260_models,
6510                                                   alc260_cfg_tbl);
6511         if (board_config < 0) {
6512                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6513                            codec->chip_name);
6514                 board_config = ALC260_AUTO;
6515         }
6516
6517         if (board_config == ALC260_AUTO) {
6518                 /* automatic parse from the BIOS config */
6519                 err = alc260_parse_auto_config(codec);
6520                 if (err < 0) {
6521                         alc_free(codec);
6522                         return err;
6523                 } else if (!err) {
6524                         printk(KERN_INFO
6525                                "hda_codec: Cannot set up configuration "
6526                                "from BIOS.  Using base mode...\n");
6527                         board_config = ALC260_BASIC;
6528                 }
6529         }
6530
6531         err = snd_hda_attach_beep_device(codec, 0x1);
6532         if (err < 0) {
6533                 alc_free(codec);
6534                 return err;
6535         }
6536
6537         if (board_config != ALC260_AUTO)
6538                 setup_preset(codec, &alc260_presets[board_config]);
6539
6540         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6541         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6542
6543         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6544         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6545
6546         if (!spec->adc_nids && spec->input_mux) {
6547                 /* check whether NID 0x04 is valid */
6548                 unsigned int wcap = get_wcaps(codec, 0x04);
6549                 wcap = get_wcaps_type(wcap);
6550                 /* get type */
6551                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6552                         spec->adc_nids = alc260_adc_nids_alt;
6553                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6554                 } else {
6555                         spec->adc_nids = alc260_adc_nids;
6556                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6557                 }
6558         }
6559         set_capture_mixer(codec);
6560         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6561
6562         spec->vmaster_nid = 0x08;
6563
6564         codec->patch_ops = alc_patch_ops;
6565         if (board_config == ALC260_AUTO)
6566                 spec->init_hook = alc260_auto_init;
6567 #ifdef CONFIG_SND_HDA_POWER_SAVE
6568         if (!spec->loopback.amplist)
6569                 spec->loopback.amplist = alc260_loopbacks;
6570 #endif
6571         codec->proc_widget_hook = print_realtek_coef;
6572
6573         return 0;
6574 }
6575
6576
6577 /*
6578  * ALC882/883/885/888/889 support
6579  *
6580  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6581  * configuration.  Each pin widget can choose any input DACs and a mixer.
6582  * Each ADC is connected from a mixer of all inputs.  This makes possible
6583  * 6-channel independent captures.
6584  *
6585  * In addition, an independent DAC for the multi-playback (not used in this
6586  * driver yet).
6587  */
6588 #define ALC882_DIGOUT_NID       0x06
6589 #define ALC882_DIGIN_NID        0x0a
6590 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6591 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6592 #define ALC1200_DIGOUT_NID      0x10
6593
6594
6595 static struct hda_channel_mode alc882_ch_modes[1] = {
6596         { 8, NULL }
6597 };
6598
6599 /* DACs */
6600 static hda_nid_t alc882_dac_nids[4] = {
6601         /* front, rear, clfe, rear_surr */
6602         0x02, 0x03, 0x04, 0x05
6603 };
6604 #define alc883_dac_nids         alc882_dac_nids
6605
6606 /* ADCs */
6607 #define alc882_adc_nids         alc880_adc_nids
6608 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6609 #define alc883_adc_nids         alc882_adc_nids_alt
6610 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6611 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6612 #define alc889_adc_nids         alc880_adc_nids
6613
6614 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6615 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6616 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6617 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6618 #define alc889_capsrc_nids      alc882_capsrc_nids
6619
6620 /* input MUX */
6621 /* FIXME: should be a matrix-type input source selection */
6622
6623 static struct hda_input_mux alc882_capture_source = {
6624         .num_items = 4,
6625         .items = {
6626                 { "Mic", 0x0 },
6627                 { "Front Mic", 0x1 },
6628                 { "Line", 0x2 },
6629                 { "CD", 0x4 },
6630         },
6631 };
6632
6633 #define alc883_capture_source   alc882_capture_source
6634
6635 static struct hda_input_mux alc889_capture_source = {
6636         .num_items = 3,
6637         .items = {
6638                 { "Front Mic", 0x0 },
6639                 { "Mic", 0x3 },
6640                 { "Line", 0x2 },
6641         },
6642 };
6643
6644 static struct hda_input_mux mb5_capture_source = {
6645         .num_items = 3,
6646         .items = {
6647                 { "Mic", 0x1 },
6648                 { "Line", 0x2 },
6649                 { "CD", 0x4 },
6650         },
6651 };
6652
6653 static struct hda_input_mux alc883_3stack_6ch_intel = {
6654         .num_items = 4,
6655         .items = {
6656                 { "Mic", 0x1 },
6657                 { "Front Mic", 0x0 },
6658                 { "Line", 0x2 },
6659                 { "CD", 0x4 },
6660         },
6661 };
6662
6663 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6664         .num_items = 2,
6665         .items = {
6666                 { "Mic", 0x1 },
6667                 { "Line", 0x2 },
6668         },
6669 };
6670
6671 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6672         .num_items = 4,
6673         .items = {
6674                 { "Mic", 0x0 },
6675                 { "iMic", 0x1 },
6676                 { "Line", 0x2 },
6677                 { "CD", 0x4 },
6678         },
6679 };
6680
6681 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6682         .num_items = 2,
6683         .items = {
6684                 { "Mic", 0x0 },
6685                 { "Int Mic", 0x1 },
6686         },
6687 };
6688
6689 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6690         .num_items = 3,
6691         .items = {
6692                 { "Mic", 0x0 },
6693                 { "Front Mic", 0x1 },
6694                 { "Line", 0x4 },
6695         },
6696 };
6697
6698 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6699         .num_items = 2,
6700         .items = {
6701                 { "Mic", 0x0 },
6702                 { "Line", 0x2 },
6703         },
6704 };
6705
6706 static struct hda_input_mux alc889A_mb31_capture_source = {
6707         .num_items = 2,
6708         .items = {
6709                 { "Mic", 0x0 },
6710                 /* Front Mic (0x01) unused */
6711                 { "Line", 0x2 },
6712                 /* Line 2 (0x03) unused */
6713                 /* CD (0x04) unused? */
6714         },
6715 };
6716
6717 /*
6718  * 2ch mode
6719  */
6720 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6721         { 2, NULL }
6722 };
6723
6724 /*
6725  * 2ch mode
6726  */
6727 static struct hda_verb alc882_3ST_ch2_init[] = {
6728         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6729         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6730         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6731         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6732         { } /* end */
6733 };
6734
6735 /*
6736  * 4ch mode
6737  */
6738 static struct hda_verb alc882_3ST_ch4_init[] = {
6739         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6740         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6741         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6742         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6743         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6744         { } /* end */
6745 };
6746
6747 /*
6748  * 6ch mode
6749  */
6750 static struct hda_verb alc882_3ST_ch6_init[] = {
6751         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6752         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6753         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6754         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6755         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6756         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6757         { } /* end */
6758 };
6759
6760 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6761         { 2, alc882_3ST_ch2_init },
6762         { 4, alc882_3ST_ch4_init },
6763         { 6, alc882_3ST_ch6_init },
6764 };
6765
6766 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6767
6768 /*
6769  * 2ch mode
6770  */
6771 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6772         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6773         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6774         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6775         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6776         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6777         { } /* end */
6778 };
6779
6780 /*
6781  * 4ch mode
6782  */
6783 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6784         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6785         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6786         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6787         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6788         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6789         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6790         { } /* end */
6791 };
6792
6793 /*
6794  * 6ch mode
6795  */
6796 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6797         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6798         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6799         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6800         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6801         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6802         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6803         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6804         { } /* end */
6805 };
6806
6807 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6808         { 2, alc883_3ST_ch2_clevo_init },
6809         { 4, alc883_3ST_ch4_clevo_init },
6810         { 6, alc883_3ST_ch6_clevo_init },
6811 };
6812
6813
6814 /*
6815  * 6ch mode
6816  */
6817 static struct hda_verb alc882_sixstack_ch6_init[] = {
6818         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6819         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6820         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6821         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6822         { } /* end */
6823 };
6824
6825 /*
6826  * 8ch mode
6827  */
6828 static struct hda_verb alc882_sixstack_ch8_init[] = {
6829         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6830         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6831         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6832         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6833         { } /* end */
6834 };
6835
6836 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6837         { 6, alc882_sixstack_ch6_init },
6838         { 8, alc882_sixstack_ch8_init },
6839 };
6840
6841 /*
6842  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6843  */
6844
6845 /*
6846  * 2ch mode
6847  */
6848 static struct hda_verb alc885_mbp_ch2_init[] = {
6849         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6850         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6851         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6852         { } /* end */
6853 };
6854
6855 /*
6856  * 4ch mode
6857  */
6858 static struct hda_verb alc885_mbp_ch4_init[] = {
6859         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6860         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6861         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6862         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6863         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6864         { } /* end */
6865 };
6866
6867 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6868         { 2, alc885_mbp_ch2_init },
6869         { 4, alc885_mbp_ch4_init },
6870 };
6871
6872 /*
6873  * 2ch
6874  * Speakers/Woofer/HP = Front
6875  * LineIn = Input
6876  */
6877 static struct hda_verb alc885_mb5_ch2_init[] = {
6878         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6879         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6880         { } /* end */
6881 };
6882
6883 /*
6884  * 6ch mode
6885  * Speakers/HP = Front
6886  * Woofer = LFE
6887  * LineIn = Surround
6888  */
6889 static struct hda_verb alc885_mb5_ch6_init[] = {
6890         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6891         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6892         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6893         { } /* end */
6894 };
6895
6896 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6897         { 2, alc885_mb5_ch2_init },
6898         { 6, alc885_mb5_ch6_init },
6899 };
6900
6901
6902 /*
6903  * 2ch mode
6904  */
6905 static struct hda_verb alc883_4ST_ch2_init[] = {
6906         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6907         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6908         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6909         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6910         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6911         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6912         { } /* end */
6913 };
6914
6915 /*
6916  * 4ch mode
6917  */
6918 static struct hda_verb alc883_4ST_ch4_init[] = {
6919         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6920         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6921         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6922         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6923         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6924         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6925         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6926         { } /* end */
6927 };
6928
6929 /*
6930  * 6ch mode
6931  */
6932 static struct hda_verb alc883_4ST_ch6_init[] = {
6933         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6934         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6935         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6936         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6937         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6938         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6939         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6940         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6941         { } /* end */
6942 };
6943
6944 /*
6945  * 8ch mode
6946  */
6947 static struct hda_verb alc883_4ST_ch8_init[] = {
6948         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6949         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6950         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6951         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6952         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6953         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6954         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6955         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6956         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6957         { } /* end */
6958 };
6959
6960 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6961         { 2, alc883_4ST_ch2_init },
6962         { 4, alc883_4ST_ch4_init },
6963         { 6, alc883_4ST_ch6_init },
6964         { 8, alc883_4ST_ch8_init },
6965 };
6966
6967
6968 /*
6969  * 2ch mode
6970  */
6971 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6972         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6973         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6974         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6975         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6976         { } /* end */
6977 };
6978
6979 /*
6980  * 4ch mode
6981  */
6982 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6983         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6984         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6985         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6986         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6987         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6988         { } /* end */
6989 };
6990
6991 /*
6992  * 6ch mode
6993  */
6994 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6995         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6996         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6997         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6998         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6999         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7000         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7001         { } /* end */
7002 };
7003
7004 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7005         { 2, alc883_3ST_ch2_intel_init },
7006         { 4, alc883_3ST_ch4_intel_init },
7007         { 6, alc883_3ST_ch6_intel_init },
7008 };
7009
7010 /*
7011  * 2ch mode
7012  */
7013 static struct hda_verb alc889_ch2_intel_init[] = {
7014         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7015         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7016         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7017         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7018         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7019         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7020         { } /* end */
7021 };
7022
7023 /*
7024  * 6ch mode
7025  */
7026 static struct hda_verb alc889_ch6_intel_init[] = {
7027         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7028         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7029         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7030         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7031         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7032         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7033         { } /* end */
7034 };
7035
7036 /*
7037  * 8ch mode
7038  */
7039 static struct hda_verb alc889_ch8_intel_init[] = {
7040         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7041         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7042         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7043         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7044         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7045         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7046         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7047         { } /* end */
7048 };
7049
7050 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7051         { 2, alc889_ch2_intel_init },
7052         { 6, alc889_ch6_intel_init },
7053         { 8, alc889_ch8_intel_init },
7054 };
7055
7056 /*
7057  * 6ch mode
7058  */
7059 static struct hda_verb alc883_sixstack_ch6_init[] = {
7060         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7061         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7062         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7063         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7064         { } /* end */
7065 };
7066
7067 /*
7068  * 8ch mode
7069  */
7070 static struct hda_verb alc883_sixstack_ch8_init[] = {
7071         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7072         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7073         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7074         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7075         { } /* end */
7076 };
7077
7078 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7079         { 6, alc883_sixstack_ch6_init },
7080         { 8, alc883_sixstack_ch8_init },
7081 };
7082
7083
7084 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7085  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7086  */
7087 static struct snd_kcontrol_new alc882_base_mixer[] = {
7088         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7089         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7090         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7091         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7092         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7093         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7094         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7095         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7096         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7097         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7098         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7099         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7100         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7101         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7102         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7103         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7104         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7105         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7106         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7107         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7108         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7109         { } /* end */
7110 };
7111
7112 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7113         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7114         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7115         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7116         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7117         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7118         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7119         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7120         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7121         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7122         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7123         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7124         { } /* end */
7125 };
7126
7127 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7128         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7129         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7130         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7131         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7132         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7133         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7134         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7135         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
7136         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7137         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7138         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7139         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7140         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7141         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7142         { } /* end */
7143 };
7144
7145 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7146         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7147         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7148         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7149         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7150         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7151         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7152         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7153         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7154         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7155         { } /* end */
7156 };
7157
7158
7159 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7160         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7161         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7162         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7163         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7164         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7165         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7166         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7167         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7168         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7169         { } /* end */
7170 };
7171
7172 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7173         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7174         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7175         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7176         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7177         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7178         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7179         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7181         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7182         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7183         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7184         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7185         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7186         { } /* end */
7187 };
7188
7189 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7190  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7191  */
7192 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7193         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7194         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7195         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7196         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7197         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7198         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7199         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7200         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7201         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7202         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7203         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7204         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7205         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7206         { } /* end */
7207 };
7208
7209 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7210         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7211         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7212         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7213         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7214         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7215         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7216         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7217         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7218         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7219         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7220         { } /* end */
7221 };
7222
7223 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7224         {
7225                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7226                 .name = "Channel Mode",
7227                 .info = alc_ch_mode_info,
7228                 .get = alc_ch_mode_get,
7229                 .put = alc_ch_mode_put,
7230         },
7231         { } /* end */
7232 };
7233
7234 static struct hda_verb alc882_base_init_verbs[] = {
7235         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7236         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7237         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7238         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7239         /* Rear mixer */
7240         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7241         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7242         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7243         /* CLFE mixer */
7244         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7245         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7246         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7247         /* Side mixer */
7248         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7249         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7250         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7251
7252         /* mute analog input loopbacks */
7253         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7254         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7255         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7256         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7257         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7258
7259         /* Front Pin: output 0 (0x0c) */
7260         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7261         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7262         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7263         /* Rear Pin: output 1 (0x0d) */
7264         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7265         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7266         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7267         /* CLFE Pin: output 2 (0x0e) */
7268         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7269         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7270         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7271         /* Side Pin: output 3 (0x0f) */
7272         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7273         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7274         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7275         /* Mic (rear) pin: input vref at 80% */
7276         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7277         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7278         /* Front Mic pin: input vref at 80% */
7279         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7280         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7281         /* Line In pin: input */
7282         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7283         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7284         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7285         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7286         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7287         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7288         /* CD pin widget for input */
7289         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7290
7291         /* FIXME: use matrix-type input source selection */
7292         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7293         /* Input mixer2 */
7294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7295         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7296         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7297         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7298         /* Input mixer3 */
7299         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7300         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7301         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7302         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7303         /* ADC2: mute amp left and right */
7304         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7305         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7306         /* ADC3: mute amp left and right */
7307         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7308         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7309
7310         { }
7311 };
7312
7313 static struct hda_verb alc882_adc1_init_verbs[] = {
7314         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7315         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7316         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7317         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7318         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7319         /* ADC1: mute amp left and right */
7320         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7321         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7322         { }
7323 };
7324
7325 static struct hda_verb alc882_eapd_verbs[] = {
7326         /* change to EAPD mode */
7327         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7328         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7329         { }
7330 };
7331
7332 static struct hda_verb alc889_eapd_verbs[] = {
7333         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7334         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7335         { }
7336 };
7337
7338 static struct hda_verb alc_hp15_unsol_verbs[] = {
7339         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7341         {}
7342 };
7343
7344 static struct hda_verb alc885_init_verbs[] = {
7345         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7348         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7349         /* Rear mixer */
7350         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7351         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7352         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7353         /* CLFE mixer */
7354         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7355         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7356         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7357         /* Side mixer */
7358         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7359         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7360         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7361
7362         /* mute analog input loopbacks */
7363         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7364         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7365         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7366
7367         /* Front HP Pin: output 0 (0x0c) */
7368         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7369         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7370         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7371         /* Front Pin: output 0 (0x0c) */
7372         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7373         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7374         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7375         /* Rear Pin: output 1 (0x0d) */
7376         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7377         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7378         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7379         /* CLFE Pin: output 2 (0x0e) */
7380         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7381         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7382         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7383         /* Side Pin: output 3 (0x0f) */
7384         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7385         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7386         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7387         /* Mic (rear) pin: input vref at 80% */
7388         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7389         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7390         /* Front Mic pin: input vref at 80% */
7391         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7392         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7393         /* Line In pin: input */
7394         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7395         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7396
7397         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7398         /* Input mixer1 */
7399         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7400         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7401         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7402         /* Input mixer2 */
7403         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7404         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7405         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7406         /* Input mixer3 */
7407         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7408         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7409         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7410         /* ADC2: mute amp left and right */
7411         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7412         /* ADC3: mute amp left and right */
7413         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7414
7415         { }
7416 };
7417
7418 static struct hda_verb alc885_init_input_verbs[] = {
7419         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7420         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7421         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7422         { }
7423 };
7424
7425
7426 /* Unmute Selector 24h and set the default input to front mic */
7427 static struct hda_verb alc889_init_input_verbs[] = {
7428         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7429         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7430         { }
7431 };
7432
7433
7434 #define alc883_init_verbs       alc882_base_init_verbs
7435
7436 /* Mac Pro test */
7437 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7438         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7439         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7440         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7441         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7442         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7443         /* FIXME: this looks suspicious...
7444         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7445         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7446         */
7447         { } /* end */
7448 };
7449
7450 static struct hda_verb alc882_macpro_init_verbs[] = {
7451         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7452         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7453         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7454         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7455         /* Front Pin: output 0 (0x0c) */
7456         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7457         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7458         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7459         /* Front Mic pin: input vref at 80% */
7460         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7461         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7462         /* Speaker:  output */
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, 0x04},
7466         /* Headphone output (output 0 - 0x0c) */
7467         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7468         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7469         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7470
7471         /* FIXME: use matrix-type input source selection */
7472         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7473         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7474         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7475         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7476         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7477         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7478         /* Input mixer2 */
7479         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7480         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7481         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7482         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7483         /* Input mixer3 */
7484         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7485         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7486         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7488         /* ADC1: mute amp left and right */
7489         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7490         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7491         /* ADC2: mute amp left and right */
7492         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7493         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7494         /* ADC3: mute amp left and right */
7495         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7496         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7497
7498         { }
7499 };
7500
7501 /* Macbook 5,1 */
7502 static struct hda_verb alc885_mb5_init_verbs[] = {
7503         /* DACs */
7504         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7505         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7506         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7507         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7508         /* Front mixer */
7509         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7510         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7511         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7512         /* Surround mixer */
7513         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7514         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7515         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7516         /* LFE mixer */
7517         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7518         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7519         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7520         /* HP mixer */
7521         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7522         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7523         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7524         /* Front Pin (0x0c) */
7525         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7526         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7527         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7528         /* LFE Pin (0x0e) */
7529         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7530         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7531         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7532         /* HP Pin (0x0f) */
7533         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7534         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7535         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7536         /* Front Mic pin: input vref at 80% */
7537         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7538         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7539         /* Line In pin */
7540         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7541         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7542
7543         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7544         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7545         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7546         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7547         { }
7548 };
7549
7550 /* Macbook Pro rev3 */
7551 static struct hda_verb alc885_mbp3_init_verbs[] = {
7552         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7554         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7555         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7556         /* Rear mixer */
7557         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7558         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7559         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7560         /* HP mixer */
7561         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7562         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7563         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7564         /* Front Pin: output 0 (0x0c) */
7565         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7566         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7567         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7568         /* HP Pin: output 0 (0x0e) */
7569         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7570         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7571         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7572         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7573         /* Mic (rear) pin: input vref at 80% */
7574         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7575         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7576         /* Front Mic pin: input vref at 80% */
7577         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7578         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7579         /* Line In pin: use output 1 when in LineOut mode */
7580         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7581         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7582         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7583
7584         /* FIXME: use matrix-type input source selection */
7585         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7586         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7587         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7588         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7589         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7590         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7591         /* Input mixer2 */
7592         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7593         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7594         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7595         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7596         /* Input mixer3 */
7597         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7598         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7599         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7601         /* ADC1: mute amp left and right */
7602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7603         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7604         /* ADC2: mute amp left and right */
7605         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7606         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7607         /* ADC3: mute amp left and right */
7608         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7609         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7610
7611         { }
7612 };
7613
7614 /* iMac 9,1 */
7615 static struct hda_verb alc885_imac91_init_verbs[] = {
7616         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7617         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7618         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7619         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7620         /* Rear mixer */
7621         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7622         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7623         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7624         /* HP Pin: output 0 (0x0c) */
7625         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7626         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7627         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7628         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7629         /* Internal Speakers: output 0 (0x0d) */
7630         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7631         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7632         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7633         /* Mic (rear) pin: input vref at 80% */
7634         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7635         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7636         /* Front Mic pin: input vref at 80% */
7637         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7638         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7639         /* Line In pin: use output 1 when in LineOut mode */
7640         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7641         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7642         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7643
7644         /* FIXME: use matrix-type input source selection */
7645         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7646         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7647         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7648         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7649         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7650         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7651         /* Input mixer2 */
7652         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7653         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7654         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7655         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7656         /* Input mixer3 */
7657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7658         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7659         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7660         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7661         /* ADC1: mute amp left and right */
7662         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7663         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7664         /* ADC2: mute amp left and right */
7665         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7666         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7667         /* ADC3: mute amp left and right */
7668         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7669         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7670
7671         { }
7672 };
7673
7674 /* iMac 24 mixer. */
7675 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7676         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7677         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7678         { } /* end */
7679 };
7680
7681 /* iMac 24 init verbs. */
7682 static struct hda_verb alc885_imac24_init_verbs[] = {
7683         /* Internal speakers: output 0 (0x0c) */
7684         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7685         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7686         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7687         /* Internal speakers: output 0 (0x0c) */
7688         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7689         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7690         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7691         /* Headphone: output 0 (0x0c) */
7692         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7693         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7694         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7695         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7696         /* Front Mic: input vref at 80% */
7697         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7698         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7699         { }
7700 };
7701
7702 /* Toggle speaker-output according to the hp-jack state */
7703 static void alc885_imac24_setup(struct hda_codec *codec)
7704 {
7705         struct alc_spec *spec = codec->spec;
7706
7707         spec->autocfg.hp_pins[0] = 0x14;
7708         spec->autocfg.speaker_pins[0] = 0x18;
7709         spec->autocfg.speaker_pins[1] = 0x1a;
7710 }
7711
7712 static void alc885_mbp3_setup(struct hda_codec *codec)
7713 {
7714         struct alc_spec *spec = codec->spec;
7715
7716         spec->autocfg.hp_pins[0] = 0x15;
7717         spec->autocfg.speaker_pins[0] = 0x14;
7718 }
7719
7720 static void alc885_imac91_automute(struct hda_codec *codec)
7721 {
7722         unsigned int present;
7723
7724         present = snd_hda_codec_read(codec, 0x14, 0,
7725                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
7726         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
7727                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7728         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_OUTPUT, 0,
7729                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
7730
7731 }
7732
7733 static void alc885_imac91_unsol_event(struct hda_codec *codec,
7734                                     unsigned int res)
7735 {
7736         /* Headphone insertion or removal. */
7737         if ((res >> 26) == ALC880_HP_EVENT)
7738                 alc885_imac91_automute(codec);
7739 }
7740
7741 static struct hda_verb alc882_targa_verbs[] = {
7742         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7743         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7744
7745         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7746         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7747
7748         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7749         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7750         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7751
7752         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7753         { } /* end */
7754 };
7755
7756 /* toggle speaker-output according to the hp-jack state */
7757 static void alc882_targa_automute(struct hda_codec *codec)
7758 {
7759         struct alc_spec *spec = codec->spec;
7760         alc_automute_amp(codec);
7761         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7762                                   spec->jack_present ? 1 : 3);
7763 }
7764
7765 static void alc882_targa_setup(struct hda_codec *codec)
7766 {
7767         struct alc_spec *spec = codec->spec;
7768
7769         spec->autocfg.hp_pins[0] = 0x14;
7770         spec->autocfg.speaker_pins[0] = 0x1b;
7771 }
7772
7773 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7774 {
7775         if ((res >> 26) == ALC880_HP_EVENT)
7776                 alc882_targa_automute(codec);
7777 }
7778
7779 static struct hda_verb alc882_asus_a7j_verbs[] = {
7780         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7781         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7782
7783         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7784         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7785         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7786
7787         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7788         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7789         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7790
7791         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7792         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7793         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7794         { } /* end */
7795 };
7796
7797 static struct hda_verb alc882_asus_a7m_verbs[] = {
7798         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7799         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7800
7801         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7802         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7803         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7804
7805         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7806         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7807         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7808
7809         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7810         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7811         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7812         { } /* end */
7813 };
7814
7815 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7816 {
7817         unsigned int gpiostate, gpiomask, gpiodir;
7818
7819         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7820                                        AC_VERB_GET_GPIO_DATA, 0);
7821
7822         if (!muted)
7823                 gpiostate |= (1 << pin);
7824         else
7825                 gpiostate &= ~(1 << pin);
7826
7827         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7828                                       AC_VERB_GET_GPIO_MASK, 0);
7829         gpiomask |= (1 << pin);
7830
7831         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7832                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7833         gpiodir |= (1 << pin);
7834
7835
7836         snd_hda_codec_write(codec, codec->afg, 0,
7837                             AC_VERB_SET_GPIO_MASK, gpiomask);
7838         snd_hda_codec_write(codec, codec->afg, 0,
7839                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7840
7841         msleep(1);
7842
7843         snd_hda_codec_write(codec, codec->afg, 0,
7844                             AC_VERB_SET_GPIO_DATA, gpiostate);
7845 }
7846
7847 /* set up GPIO at initialization */
7848 static void alc885_macpro_init_hook(struct hda_codec *codec)
7849 {
7850         alc882_gpio_mute(codec, 0, 0);
7851         alc882_gpio_mute(codec, 1, 0);
7852 }
7853
7854 /* set up GPIO and update auto-muting at initialization */
7855 static void alc885_imac24_init_hook(struct hda_codec *codec)
7856 {
7857         alc885_macpro_init_hook(codec);
7858         alc_automute_amp(codec);
7859 }
7860
7861 /*
7862  * generic initialization of ADC, input mixers and output mixers
7863  */
7864 static struct hda_verb alc883_auto_init_verbs[] = {
7865         /*
7866          * Unmute ADC0-2 and set the default input to mic-in
7867          */
7868         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7869         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7870         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7871         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7872
7873         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7874          * mixer widget
7875          * Note: PASD motherboards uses the Line In 2 as the input for
7876          * front panel mic (mic 2)
7877          */
7878         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7879         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7880         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7881         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7882         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7883         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7884
7885         /*
7886          * Set up output mixers (0x0c - 0x0f)
7887          */
7888         /* set vol=0 to output mixers */
7889         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7890         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7891         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7892         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7893         /* set up input amps for analog loopback */
7894         /* Amp Indices: DAC = 0, mixer = 1 */
7895         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7896         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7897         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7898         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7899         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7900         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7901         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7902         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7903         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7904         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7905
7906         /* FIXME: use matrix-type input source selection */
7907         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7908         /* Input mixer2 */
7909         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7910         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7911         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7912         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7913         /* Input mixer3 */
7914         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7915         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7916         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7917         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7918
7919         { }
7920 };
7921
7922 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7923 static struct hda_verb alc889A_mb31_ch2_init[] = {
7924         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7925         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7926         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7927         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7928         { } /* end */
7929 };
7930
7931 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7932 static struct hda_verb alc889A_mb31_ch4_init[] = {
7933         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7934         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7935         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7936         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7937         { } /* end */
7938 };
7939
7940 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7941 static struct hda_verb alc889A_mb31_ch5_init[] = {
7942         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7943         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7944         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7945         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7946         { } /* end */
7947 };
7948
7949 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7950 static struct hda_verb alc889A_mb31_ch6_init[] = {
7951         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7952         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7953         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7954         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7955         { } /* end */
7956 };
7957
7958 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7959         { 2, alc889A_mb31_ch2_init },
7960         { 4, alc889A_mb31_ch4_init },
7961         { 5, alc889A_mb31_ch5_init },
7962         { 6, alc889A_mb31_ch6_init },
7963 };
7964
7965 static struct hda_verb alc883_medion_eapd_verbs[] = {
7966         /* eanable EAPD on medion laptop */
7967         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7968         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7969         { }
7970 };
7971
7972 #define alc883_base_mixer       alc882_base_mixer
7973
7974 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7975         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7976         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7977         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7978         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7979         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7980         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7981         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7982         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7983         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7984         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7985         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7986         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7987         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7988         { } /* end */
7989 };
7990
7991 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7992         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7993         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7994         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7995         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7996         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7997         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7998         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7999         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8000         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8001         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8002         { } /* end */
8003 };
8004
8005 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8006         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8007         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8008         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8009         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8011         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8012         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8013         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8014         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8015         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8016         { } /* end */
8017 };
8018
8019 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8020         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8021         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8022         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8023         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8024         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8025         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8026         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8027         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8028         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8029         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8030         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8031         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8032         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8033         { } /* end */
8034 };
8035
8036 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8037         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8038         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8039         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8040         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8041         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8042         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8043         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8044         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8045         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8046         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8047         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8048         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8049         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8050         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8051         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8052         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8053         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8054         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8055         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8056         { } /* end */
8057 };
8058
8059 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8060         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8061         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8062         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8063         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8064         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8065                               HDA_OUTPUT),
8066         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8067         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8068         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8069         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8070         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8071         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8072         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8073         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8074         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8075         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8076         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8077         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8078         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8079         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8080         { } /* end */
8081 };
8082
8083 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8084         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8085         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8086         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8087         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8088         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8089                               HDA_OUTPUT),
8090         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8091         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8092         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8093         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8094         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8095         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8096         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8097         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8099         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8100         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8101         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8102         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8103         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8104         { } /* end */
8105 };
8106
8107 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8108         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8109         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8110         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8111         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8112         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8113         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8114         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8115         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8116         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8117         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8118         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8119         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8120         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8121         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8122         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8123         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8124         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8125         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8126         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8127         { } /* end */
8128 };
8129
8130 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8131         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8132         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8133         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8134         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8135         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8136         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8137         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8138         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8139         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8140         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8141         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8142         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8143         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8144         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8145         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8146         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8147         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8148         { } /* end */
8149 };
8150
8151 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8152         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8153         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8154         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8155         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8156         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8157         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8158         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8159         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8160         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8161         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8162         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8163         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8164         { } /* end */
8165 };
8166
8167 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8168         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8169         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8170         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8171         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8172         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8173         { } /* end */
8174 };
8175
8176 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8177         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8178         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8179         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8180         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8181         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8182         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8183         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8184         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8185         { } /* end */
8186 };
8187
8188 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8189         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8190         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8191         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8192         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8193         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8194         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8195         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8196         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8197         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8198         { } /* end */
8199 };
8200
8201 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8202         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8203         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8204         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8205         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8206         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8207         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8208         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8209         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8210         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8211         { } /* end */
8212 };
8213
8214 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8216         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8217         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8218         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8219         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8220         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8221         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8222         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8223         { } /* end */
8224 };
8225
8226 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8227         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8228         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8229         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8230         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8231         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8232         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8233         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8234         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8235         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8236         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8237         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8238         { } /* end */
8239 };
8240
8241 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8242         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8243         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8244         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8245         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8246         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8247                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8248         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8249         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8250         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8251         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8252         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8253         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8254         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8255         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8256         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8257         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8258         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8259         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8260         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8261         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8262         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8263         { } /* end */
8264 };
8265
8266 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8267         /* Output mixers */
8268         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8269         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8270         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8271         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8272         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8273                 HDA_OUTPUT),
8274         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8275         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8276         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8277         /* Output switches */
8278         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8279         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8280         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8281         /* Boost mixers */
8282         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8283         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8284         /* Input mixers */
8285         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8286         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8287         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8288         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8289         { } /* end */
8290 };
8291
8292 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8293         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8294         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8295         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8296         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8297         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8298         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8299         { } /* end */
8300 };
8301
8302 static struct hda_bind_ctls alc883_bind_cap_vol = {
8303         .ops = &snd_hda_bind_vol,
8304         .values = {
8305                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8306                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8307                 0
8308         },
8309 };
8310
8311 static struct hda_bind_ctls alc883_bind_cap_switch = {
8312         .ops = &snd_hda_bind_sw,
8313         .values = {
8314                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8315                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8316                 0
8317         },
8318 };
8319
8320 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8321         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8322         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8323         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8324         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8325         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8326         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8327         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8328         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8329         { } /* end */
8330 };
8331
8332 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8333         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8334         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8335         {
8336                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8337                 /* .name = "Capture Source", */
8338                 .name = "Input Source",
8339                 .count = 1,
8340                 .info = alc_mux_enum_info,
8341                 .get = alc_mux_enum_get,
8342                 .put = alc_mux_enum_put,
8343         },
8344         { } /* end */
8345 };
8346
8347 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8348         {
8349                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8350                 .name = "Channel Mode",
8351                 .info = alc_ch_mode_info,
8352                 .get = alc_ch_mode_get,
8353                 .put = alc_ch_mode_put,
8354         },
8355         { } /* end */
8356 };
8357
8358 /* toggle speaker-output according to the hp-jack state */
8359 static void alc883_mitac_setup(struct hda_codec *codec)
8360 {
8361         struct alc_spec *spec = codec->spec;
8362
8363         spec->autocfg.hp_pins[0] = 0x15;
8364         spec->autocfg.speaker_pins[0] = 0x14;
8365         spec->autocfg.speaker_pins[1] = 0x17;
8366 }
8367
8368 /* auto-toggle front mic */
8369 /*
8370 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8371 {
8372         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8373
8374         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8375 }
8376 */
8377
8378 static struct hda_verb alc883_mitac_verbs[] = {
8379         /* HP */
8380         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8381         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8382         /* Subwoofer */
8383         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8384         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8385
8386         /* enable unsolicited event */
8387         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8388         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8389
8390         { } /* end */
8391 };
8392
8393 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8394         /* HP */
8395         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8396         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8397         /* Int speaker */
8398         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8399
8400         /* enable unsolicited event */
8401         /*
8402         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8403         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8404         */
8405
8406         { } /* end */
8407 };
8408
8409 static struct hda_verb alc883_clevo_m720_verbs[] = {
8410         /* HP */
8411         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8412         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8413         /* Int speaker */
8414         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8415         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8416
8417         /* enable unsolicited event */
8418         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8419         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8420
8421         { } /* end */
8422 };
8423
8424 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8425         /* HP */
8426         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8427         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8428         /* Subwoofer */
8429         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8430         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8431
8432         /* enable unsolicited event */
8433         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8434
8435         { } /* end */
8436 };
8437
8438 static struct hda_verb alc883_targa_verbs[] = {
8439         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8440         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8441
8442         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8443         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8444
8445 /* Connect Line-Out side jack (SPDIF) to Side */
8446         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8447         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8448         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8449 /* Connect Mic jack to CLFE */
8450         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8451         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8452         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8453 /* Connect Line-in jack to Surround */
8454         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8455         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8456         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8457 /* Connect HP out jack to Front */
8458         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8459         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8460         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8461
8462         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8463
8464         { } /* end */
8465 };
8466
8467 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8468         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8469         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8470         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8471         { } /* end */
8472 };
8473
8474 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8475         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8476         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8477         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8478         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8479         { } /* end */
8480 };
8481
8482 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8483         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8484         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8485         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8486         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8487         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8488         { } /* end */
8489 };
8490
8491 static struct hda_verb alc883_haier_w66_verbs[] = {
8492         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8493         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8494
8495         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8496
8497         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8498         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8499         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8500         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8501         { } /* end */
8502 };
8503
8504 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8505         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8506         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8507         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8508         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8509         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8510         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8511         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8512         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8513         { } /* end */
8514 };
8515
8516 static struct hda_verb alc888_6st_dell_verbs[] = {
8517         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8518         { }
8519 };
8520
8521 static struct hda_verb alc883_vaiott_verbs[] = {
8522         /* HP */
8523         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8524         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8525
8526         /* enable unsolicited event */
8527         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8528
8529         { } /* end */
8530 };
8531
8532 static void alc888_3st_hp_setup(struct hda_codec *codec)
8533 {
8534         struct alc_spec *spec = codec->spec;
8535
8536         spec->autocfg.hp_pins[0] = 0x1b;
8537         spec->autocfg.speaker_pins[0] = 0x14;
8538         spec->autocfg.speaker_pins[1] = 0x16;
8539         spec->autocfg.speaker_pins[2] = 0x18;
8540 }
8541
8542 static struct hda_verb alc888_3st_hp_verbs[] = {
8543         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8544         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8545         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8546         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8547         { } /* end */
8548 };
8549
8550 /*
8551  * 2ch mode
8552  */
8553 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8554         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8555         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8556         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8557         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8558         { } /* end */
8559 };
8560
8561 /*
8562  * 4ch mode
8563  */
8564 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8565         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8566         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8567         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8568         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8569         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8570         { } /* end */
8571 };
8572
8573 /*
8574  * 6ch mode
8575  */
8576 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8577         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8578         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8579         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8580         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8581         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8582         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8583         { } /* end */
8584 };
8585
8586 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8587         { 2, alc888_3st_hp_2ch_init },
8588         { 4, alc888_3st_hp_4ch_init },
8589         { 6, alc888_3st_hp_6ch_init },
8590 };
8591
8592 /* toggle front-jack and RCA according to the hp-jack state */
8593 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8594 {
8595         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8596
8597         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8598                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8599         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8600                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8601 }
8602
8603 /* toggle RCA according to the front-jack state */
8604 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8605 {
8606         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8607
8608         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8609                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8610 }
8611
8612 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8613                                              unsigned int res)
8614 {
8615         if ((res >> 26) == ALC880_HP_EVENT)
8616                 alc888_lenovo_ms7195_front_automute(codec);
8617         if ((res >> 26) == ALC880_FRONT_EVENT)
8618                 alc888_lenovo_ms7195_rca_automute(codec);
8619 }
8620
8621 static struct hda_verb alc883_medion_md2_verbs[] = {
8622         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8623         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8624
8625         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8626
8627         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8628         { } /* end */
8629 };
8630
8631 /* toggle speaker-output according to the hp-jack state */
8632 static void alc883_medion_md2_setup(struct hda_codec *codec)
8633 {
8634         struct alc_spec *spec = codec->spec;
8635
8636         spec->autocfg.hp_pins[0] = 0x14;
8637         spec->autocfg.speaker_pins[0] = 0x15;
8638 }
8639
8640 /* toggle speaker-output according to the hp-jack state */
8641 #define alc883_targa_init_hook          alc882_targa_init_hook
8642 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8643
8644 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8645 {
8646         unsigned int present;
8647
8648         present = snd_hda_jack_detect(codec, 0x18);
8649         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8650                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8651 }
8652
8653 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8654 {
8655         struct alc_spec *spec = codec->spec;
8656
8657         spec->autocfg.hp_pins[0] = 0x15;
8658         spec->autocfg.speaker_pins[0] = 0x14;
8659 }
8660
8661 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8662 {
8663         alc_automute_amp(codec);
8664         alc883_clevo_m720_mic_automute(codec);
8665 }
8666
8667 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8668                                            unsigned int res)
8669 {
8670         switch (res >> 26) {
8671         case ALC880_MIC_EVENT:
8672                 alc883_clevo_m720_mic_automute(codec);
8673                 break;
8674         default:
8675                 alc_automute_amp_unsol_event(codec, res);
8676                 break;
8677         }
8678 }
8679
8680 /* toggle speaker-output according to the hp-jack state */
8681 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8682 {
8683         struct alc_spec *spec = codec->spec;
8684
8685         spec->autocfg.hp_pins[0] = 0x14;
8686         spec->autocfg.speaker_pins[0] = 0x15;
8687 }
8688
8689 static void alc883_haier_w66_setup(struct hda_codec *codec)
8690 {
8691         struct alc_spec *spec = codec->spec;
8692
8693         spec->autocfg.hp_pins[0] = 0x1b;
8694         spec->autocfg.speaker_pins[0] = 0x14;
8695 }
8696
8697 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8698 {
8699         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8700
8701         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8702                                  HDA_AMP_MUTE, bits);
8703 }
8704
8705 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8706 {
8707         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8708
8709         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8710                                  HDA_AMP_MUTE, bits);
8711         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8712                                  HDA_AMP_MUTE, bits);
8713 }
8714
8715 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8716                                            unsigned int res)
8717 {
8718         if ((res >> 26) == ALC880_HP_EVENT)
8719                 alc883_lenovo_101e_all_automute(codec);
8720         if ((res >> 26) == ALC880_FRONT_EVENT)
8721                 alc883_lenovo_101e_ispeaker_automute(codec);
8722 }
8723
8724 /* toggle speaker-output according to the hp-jack state */
8725 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8726 {
8727         struct alc_spec *spec = codec->spec;
8728
8729         spec->autocfg.hp_pins[0] = 0x14;
8730         spec->autocfg.speaker_pins[0] = 0x15;
8731         spec->autocfg.speaker_pins[1] = 0x16;
8732 }
8733
8734 static struct hda_verb alc883_acer_eapd_verbs[] = {
8735         /* HP Pin: output 0 (0x0c) */
8736         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8737         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8738         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8739         /* Front Pin: output 0 (0x0c) */
8740         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8741         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8742         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8743         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8744         /* eanable EAPD on medion laptop */
8745         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8746         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8747         /* enable unsolicited event */
8748         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8749         { }
8750 };
8751
8752 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8753         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8754         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8755         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8756         { } /* end */
8757 };
8758
8759 static void alc888_6st_dell_setup(struct hda_codec *codec)
8760 {
8761         struct alc_spec *spec = codec->spec;
8762
8763         spec->autocfg.hp_pins[0] = 0x1b;
8764         spec->autocfg.speaker_pins[0] = 0x14;
8765         spec->autocfg.speaker_pins[1] = 0x15;
8766         spec->autocfg.speaker_pins[2] = 0x16;
8767         spec->autocfg.speaker_pins[3] = 0x17;
8768 }
8769
8770 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8771 {
8772         struct alc_spec *spec = codec->spec;
8773
8774         spec->autocfg.hp_pins[0] = 0x1b;
8775         spec->autocfg.speaker_pins[0] = 0x14;
8776         spec->autocfg.speaker_pins[1] = 0x15;
8777         spec->autocfg.speaker_pins[2] = 0x16;
8778         spec->autocfg.speaker_pins[3] = 0x17;
8779         spec->autocfg.speaker_pins[4] = 0x1a;
8780 }
8781
8782 static void alc883_vaiott_setup(struct hda_codec *codec)
8783 {
8784         struct alc_spec *spec = codec->spec;
8785
8786         spec->autocfg.hp_pins[0] = 0x15;
8787         spec->autocfg.speaker_pins[0] = 0x14;
8788         spec->autocfg.speaker_pins[1] = 0x17;
8789 }
8790
8791 static struct hda_verb alc888_asus_m90v_verbs[] = {
8792         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8793         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8794         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8795         /* enable unsolicited event */
8796         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8797         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8798         { } /* end */
8799 };
8800
8801 static void alc883_mode2_setup(struct hda_codec *codec)
8802 {
8803         struct alc_spec *spec = codec->spec;
8804
8805         spec->autocfg.hp_pins[0] = 0x1b;
8806         spec->autocfg.speaker_pins[0] = 0x14;
8807         spec->autocfg.speaker_pins[1] = 0x15;
8808         spec->autocfg.speaker_pins[2] = 0x16;
8809         spec->ext_mic.pin = 0x18;
8810         spec->int_mic.pin = 0x19;
8811         spec->ext_mic.mux_idx = 0;
8812         spec->int_mic.mux_idx = 1;
8813         spec->auto_mic = 1;
8814 }
8815
8816 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8817         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8818         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8819         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8820         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8821         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8822         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8823         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8824         /* enable unsolicited event */
8825         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8826         { } /* end */
8827 };
8828
8829 static void alc883_eee1601_inithook(struct hda_codec *codec)
8830 {
8831         struct alc_spec *spec = codec->spec;
8832
8833         spec->autocfg.hp_pins[0] = 0x14;
8834         spec->autocfg.speaker_pins[0] = 0x1b;
8835         alc_automute_pin(codec);
8836 }
8837
8838 static struct hda_verb alc889A_mb31_verbs[] = {
8839         /* Init rear pin (used as headphone output) */
8840         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8841         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8842         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8843         /* Init line pin (used as output in 4ch and 6ch mode) */
8844         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8845         /* Init line 2 pin (used as headphone out by default) */
8846         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8847         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8848         { } /* end */
8849 };
8850
8851 /* Mute speakers according to the headphone jack state */
8852 static void alc889A_mb31_automute(struct hda_codec *codec)
8853 {
8854         unsigned int present;
8855
8856         /* Mute only in 2ch or 4ch mode */
8857         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8858             == 0x00) {
8859                 present = snd_hda_jack_detect(codec, 0x15);
8860                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8861                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8862                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8863                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8864         }
8865 }
8866
8867 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8868 {
8869         if ((res >> 26) == ALC880_HP_EVENT)
8870                 alc889A_mb31_automute(codec);
8871 }
8872
8873
8874 #ifdef CONFIG_SND_HDA_POWER_SAVE
8875 #define alc882_loopbacks        alc880_loopbacks
8876 #endif
8877
8878 /* pcm configuration: identical with ALC880 */
8879 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8880 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8881 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8882 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8883
8884 static hda_nid_t alc883_slave_dig_outs[] = {
8885         ALC1200_DIGOUT_NID, 0,
8886 };
8887
8888 static hda_nid_t alc1200_slave_dig_outs[] = {
8889         ALC883_DIGOUT_NID, 0,
8890 };
8891
8892 /*
8893  * configuration and preset
8894  */
8895 static const char *alc882_models[ALC882_MODEL_LAST] = {
8896         [ALC882_3ST_DIG]        = "3stack-dig",
8897         [ALC882_6ST_DIG]        = "6stack-dig",
8898         [ALC882_ARIMA]          = "arima",
8899         [ALC882_W2JC]           = "w2jc",
8900         [ALC882_TARGA]          = "targa",
8901         [ALC882_ASUS_A7J]       = "asus-a7j",
8902         [ALC882_ASUS_A7M]       = "asus-a7m",
8903         [ALC885_MACPRO]         = "macpro",
8904         [ALC885_MB5]            = "mb5",
8905         [ALC885_MBP3]           = "mbp3",
8906         [ALC885_IMAC24]         = "imac24",
8907         [ALC885_IMAC91]         = "imac91",
8908         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8909         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8910         [ALC883_3ST_6ch]        = "3stack-6ch",
8911         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8912         [ALC883_TARGA_DIG]      = "targa-dig",
8913         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8914         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8915         [ALC883_ACER]           = "acer",
8916         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8917         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8918         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8919         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8920         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
8921         [ALC883_MEDION]         = "medion",
8922         [ALC883_MEDION_MD2]     = "medion-md2",
8923         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8924         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8925         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8926         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8927         [ALC888_LENOVO_SKY] = "lenovo-sky",
8928         [ALC883_HAIER_W66]      = "haier-w66",
8929         [ALC888_3ST_HP]         = "3stack-hp",
8930         [ALC888_6ST_DELL]       = "6stack-dell",
8931         [ALC883_MITAC]          = "mitac",
8932         [ALC883_CLEVO_M540R]    = "clevo-m540r",
8933         [ALC883_CLEVO_M720]     = "clevo-m720",
8934         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8935         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8936         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8937         [ALC889A_INTEL]         = "intel-alc889a",
8938         [ALC889_INTEL]          = "intel-x58",
8939         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8940         [ALC889A_MB31]          = "mb31",
8941         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8942         [ALC882_AUTO]           = "auto",
8943 };
8944
8945 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8946         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8947
8948         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8949         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8950         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8951         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8952         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8953         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8954         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8955                 ALC888_ACER_ASPIRE_4930G),
8956         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8957                 ALC888_ACER_ASPIRE_4930G),
8958         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8959                 ALC888_ACER_ASPIRE_8930G),
8960         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8961                 ALC888_ACER_ASPIRE_8930G),
8962         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8963         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8964         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8965                 ALC888_ACER_ASPIRE_6530G),
8966         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8967                 ALC888_ACER_ASPIRE_6530G),
8968         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
8969                 ALC888_ACER_ASPIRE_7730G),
8970         /* default Acer -- disabled as it causes more problems.
8971          *    model=auto should work fine now
8972          */
8973         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8974
8975         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8976
8977         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8978         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8979         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8980         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8981         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8982         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8983
8984         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8985         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8986         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8987         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8988         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8989         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8990         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8991         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8992         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8993         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8994         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8995
8996         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8997         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8998         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8999         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9000         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9001         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9002         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9003         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9004         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9005
9006         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9007         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9008         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9009         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9010         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
9011         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9012         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9013         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9014         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9015         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9016         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9017         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9018         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9019         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9020         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9021         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9022         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9023         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9024         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9025         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9026         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9027         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9028         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9029         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9030         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9031         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9032         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9033         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9034         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9035
9036         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9037         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9038         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9039         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9040         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9041         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9042         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9043         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9044         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9045                       ALC883_FUJITSU_PI2515),
9046         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9047                 ALC888_FUJITSU_XA3530),
9048         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9049         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9050         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9051         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9052         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9053         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9054         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9055         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9056         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9057
9058         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9059         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9060         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9061         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9062         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9063         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9064         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
9065
9066         {}
9067 };
9068
9069 /* codec SSID table for Intel Mac */
9070 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9071         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9072         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9073         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9074         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9075         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9076         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9077         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9078         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9079         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9080         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9081         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9082         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9083         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9084          * so apparently no perfect solution yet
9085          */
9086         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9087         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9088         {} /* terminator */
9089 };
9090
9091 static struct alc_config_preset alc882_presets[] = {
9092         [ALC882_3ST_DIG] = {
9093                 .mixers = { alc882_base_mixer },
9094                 .init_verbs = { alc882_base_init_verbs,
9095                                 alc882_adc1_init_verbs },
9096                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9097                 .dac_nids = alc882_dac_nids,
9098                 .dig_out_nid = ALC882_DIGOUT_NID,
9099                 .dig_in_nid = ALC882_DIGIN_NID,
9100                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9101                 .channel_mode = alc882_ch_modes,
9102                 .need_dac_fix = 1,
9103                 .input_mux = &alc882_capture_source,
9104         },
9105         [ALC882_6ST_DIG] = {
9106                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9107                 .init_verbs = { alc882_base_init_verbs,
9108                                 alc882_adc1_init_verbs },
9109                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9110                 .dac_nids = alc882_dac_nids,
9111                 .dig_out_nid = ALC882_DIGOUT_NID,
9112                 .dig_in_nid = ALC882_DIGIN_NID,
9113                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9114                 .channel_mode = alc882_sixstack_modes,
9115                 .input_mux = &alc882_capture_source,
9116         },
9117         [ALC882_ARIMA] = {
9118                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9119                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9120                                 alc882_eapd_verbs },
9121                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9122                 .dac_nids = alc882_dac_nids,
9123                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9124                 .channel_mode = alc882_sixstack_modes,
9125                 .input_mux = &alc882_capture_source,
9126         },
9127         [ALC882_W2JC] = {
9128                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9129                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9130                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9131                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9132                 .dac_nids = alc882_dac_nids,
9133                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9134                 .channel_mode = alc880_threestack_modes,
9135                 .need_dac_fix = 1,
9136                 .input_mux = &alc882_capture_source,
9137                 .dig_out_nid = ALC882_DIGOUT_NID,
9138         },
9139         [ALC885_MBP3] = {
9140                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9141                 .init_verbs = { alc885_mbp3_init_verbs,
9142                                 alc880_gpio1_init_verbs },
9143                 .num_dacs = 2,
9144                 .dac_nids = alc882_dac_nids,
9145                 .hp_nid = 0x04,
9146                 .channel_mode = alc885_mbp_4ch_modes,
9147                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9148                 .input_mux = &alc882_capture_source,
9149                 .dig_out_nid = ALC882_DIGOUT_NID,
9150                 .dig_in_nid = ALC882_DIGIN_NID,
9151                 .unsol_event = alc_automute_amp_unsol_event,
9152                 .setup = alc885_mbp3_setup,
9153                 .init_hook = alc_automute_amp,
9154         },
9155         [ALC885_MB5] = {
9156                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9157                 .init_verbs = { alc885_mb5_init_verbs,
9158                                 alc880_gpio1_init_verbs },
9159                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9160                 .dac_nids = alc882_dac_nids,
9161                 .channel_mode = alc885_mb5_6ch_modes,
9162                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9163                 .input_mux = &mb5_capture_source,
9164                 .dig_out_nid = ALC882_DIGOUT_NID,
9165                 .dig_in_nid = ALC882_DIGIN_NID,
9166         },
9167         [ALC885_MACPRO] = {
9168                 .mixers = { alc882_macpro_mixer },
9169                 .init_verbs = { alc882_macpro_init_verbs },
9170                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9171                 .dac_nids = alc882_dac_nids,
9172                 .dig_out_nid = ALC882_DIGOUT_NID,
9173                 .dig_in_nid = ALC882_DIGIN_NID,
9174                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9175                 .channel_mode = alc882_ch_modes,
9176                 .input_mux = &alc882_capture_source,
9177                 .init_hook = alc885_macpro_init_hook,
9178         },
9179         [ALC885_IMAC24] = {
9180                 .mixers = { alc885_imac24_mixer },
9181                 .init_verbs = { alc885_imac24_init_verbs },
9182                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9183                 .dac_nids = alc882_dac_nids,
9184                 .dig_out_nid = ALC882_DIGOUT_NID,
9185                 .dig_in_nid = ALC882_DIGIN_NID,
9186                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9187                 .channel_mode = alc882_ch_modes,
9188                 .input_mux = &alc882_capture_source,
9189                 .unsol_event = alc_automute_amp_unsol_event,
9190                 .setup = alc885_imac24_setup,
9191                 .init_hook = alc885_imac24_init_hook,
9192         },
9193         [ALC885_IMAC91] = {
9194                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9195                 .init_verbs = { alc885_imac91_init_verbs,
9196                                 alc880_gpio1_init_verbs },
9197                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9198                 .dac_nids = alc882_dac_nids,
9199                 .channel_mode = alc885_mbp_4ch_modes,
9200                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9201                 .input_mux = &alc882_capture_source,
9202                 .dig_out_nid = ALC882_DIGOUT_NID,
9203                 .dig_in_nid = ALC882_DIGIN_NID,
9204                 .unsol_event = alc885_imac91_unsol_event,
9205                 .init_hook = alc885_imac91_automute,
9206         },
9207         [ALC882_TARGA] = {
9208                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9209                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9210                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9211                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9212                 .dac_nids = alc882_dac_nids,
9213                 .dig_out_nid = ALC882_DIGOUT_NID,
9214                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9215                 .adc_nids = alc882_adc_nids,
9216                 .capsrc_nids = alc882_capsrc_nids,
9217                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9218                 .channel_mode = alc882_3ST_6ch_modes,
9219                 .need_dac_fix = 1,
9220                 .input_mux = &alc882_capture_source,
9221                 .unsol_event = alc882_targa_unsol_event,
9222                 .setup = alc882_targa_setup,
9223                 .init_hook = alc882_targa_automute,
9224         },
9225         [ALC882_ASUS_A7J] = {
9226                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9227                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9228                                 alc882_asus_a7j_verbs},
9229                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9230                 .dac_nids = alc882_dac_nids,
9231                 .dig_out_nid = ALC882_DIGOUT_NID,
9232                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9233                 .adc_nids = alc882_adc_nids,
9234                 .capsrc_nids = alc882_capsrc_nids,
9235                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9236                 .channel_mode = alc882_3ST_6ch_modes,
9237                 .need_dac_fix = 1,
9238                 .input_mux = &alc882_capture_source,
9239         },
9240         [ALC882_ASUS_A7M] = {
9241                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9242                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9243                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9244                                 alc882_asus_a7m_verbs },
9245                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9246                 .dac_nids = alc882_dac_nids,
9247                 .dig_out_nid = ALC882_DIGOUT_NID,
9248                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9249                 .channel_mode = alc880_threestack_modes,
9250                 .need_dac_fix = 1,
9251                 .input_mux = &alc882_capture_source,
9252         },
9253         [ALC883_3ST_2ch_DIG] = {
9254                 .mixers = { alc883_3ST_2ch_mixer },
9255                 .init_verbs = { alc883_init_verbs },
9256                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9257                 .dac_nids = alc883_dac_nids,
9258                 .dig_out_nid = ALC883_DIGOUT_NID,
9259                 .dig_in_nid = ALC883_DIGIN_NID,
9260                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9261                 .channel_mode = alc883_3ST_2ch_modes,
9262                 .input_mux = &alc883_capture_source,
9263         },
9264         [ALC883_3ST_6ch_DIG] = {
9265                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9266                 .init_verbs = { alc883_init_verbs },
9267                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9268                 .dac_nids = alc883_dac_nids,
9269                 .dig_out_nid = ALC883_DIGOUT_NID,
9270                 .dig_in_nid = ALC883_DIGIN_NID,
9271                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9272                 .channel_mode = alc883_3ST_6ch_modes,
9273                 .need_dac_fix = 1,
9274                 .input_mux = &alc883_capture_source,
9275         },
9276         [ALC883_3ST_6ch] = {
9277                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9278                 .init_verbs = { alc883_init_verbs },
9279                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9280                 .dac_nids = alc883_dac_nids,
9281                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9282                 .channel_mode = alc883_3ST_6ch_modes,
9283                 .need_dac_fix = 1,
9284                 .input_mux = &alc883_capture_source,
9285         },
9286         [ALC883_3ST_6ch_INTEL] = {
9287                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9288                 .init_verbs = { alc883_init_verbs },
9289                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9290                 .dac_nids = alc883_dac_nids,
9291                 .dig_out_nid = ALC883_DIGOUT_NID,
9292                 .dig_in_nid = ALC883_DIGIN_NID,
9293                 .slave_dig_outs = alc883_slave_dig_outs,
9294                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9295                 .channel_mode = alc883_3ST_6ch_intel_modes,
9296                 .need_dac_fix = 1,
9297                 .input_mux = &alc883_3stack_6ch_intel,
9298         },
9299         [ALC889A_INTEL] = {
9300                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9301                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9302                                 alc_hp15_unsol_verbs },
9303                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9304                 .dac_nids = alc883_dac_nids,
9305                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9306                 .adc_nids = alc889_adc_nids,
9307                 .dig_out_nid = ALC883_DIGOUT_NID,
9308                 .dig_in_nid = ALC883_DIGIN_NID,
9309                 .slave_dig_outs = alc883_slave_dig_outs,
9310                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9311                 .channel_mode = alc889_8ch_intel_modes,
9312                 .capsrc_nids = alc889_capsrc_nids,
9313                 .input_mux = &alc889_capture_source,
9314                 .setup = alc889_automute_setup,
9315                 .init_hook = alc_automute_amp,
9316                 .unsol_event = alc_automute_amp_unsol_event,
9317                 .need_dac_fix = 1,
9318         },
9319         [ALC889_INTEL] = {
9320                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9321                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9322                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9323                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9324                 .dac_nids = alc883_dac_nids,
9325                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9326                 .adc_nids = alc889_adc_nids,
9327                 .dig_out_nid = ALC883_DIGOUT_NID,
9328                 .dig_in_nid = ALC883_DIGIN_NID,
9329                 .slave_dig_outs = alc883_slave_dig_outs,
9330                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9331                 .channel_mode = alc889_8ch_intel_modes,
9332                 .capsrc_nids = alc889_capsrc_nids,
9333                 .input_mux = &alc889_capture_source,
9334                 .setup = alc889_automute_setup,
9335                 .init_hook = alc889_intel_init_hook,
9336                 .unsol_event = alc_automute_amp_unsol_event,
9337                 .need_dac_fix = 1,
9338         },
9339         [ALC883_6ST_DIG] = {
9340                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9341                 .init_verbs = { alc883_init_verbs },
9342                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9343                 .dac_nids = alc883_dac_nids,
9344                 .dig_out_nid = ALC883_DIGOUT_NID,
9345                 .dig_in_nid = ALC883_DIGIN_NID,
9346                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9347                 .channel_mode = alc883_sixstack_modes,
9348                 .input_mux = &alc883_capture_source,
9349         },
9350         [ALC883_TARGA_DIG] = {
9351                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9352                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9353                                 alc883_targa_verbs},
9354                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9355                 .dac_nids = alc883_dac_nids,
9356                 .dig_out_nid = ALC883_DIGOUT_NID,
9357                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9358                 .channel_mode = alc883_3ST_6ch_modes,
9359                 .need_dac_fix = 1,
9360                 .input_mux = &alc883_capture_source,
9361                 .unsol_event = alc883_targa_unsol_event,
9362                 .setup = alc882_targa_setup,
9363                 .init_hook = alc882_targa_automute,
9364         },
9365         [ALC883_TARGA_2ch_DIG] = {
9366                 .mixers = { alc883_targa_2ch_mixer},
9367                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9368                                 alc883_targa_verbs},
9369                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9370                 .dac_nids = alc883_dac_nids,
9371                 .adc_nids = alc883_adc_nids_alt,
9372                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9373                 .dig_out_nid = ALC883_DIGOUT_NID,
9374                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9375                 .channel_mode = alc883_3ST_2ch_modes,
9376                 .input_mux = &alc883_capture_source,
9377                 .unsol_event = alc883_targa_unsol_event,
9378                 .setup = alc882_targa_setup,
9379                 .init_hook = alc882_targa_automute,
9380         },
9381         [ALC883_TARGA_8ch_DIG] = {
9382                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9383                             alc883_chmode_mixer },
9384                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9385                                 alc883_targa_verbs },
9386                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9387                 .dac_nids = alc883_dac_nids,
9388                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9389                 .adc_nids = alc883_adc_nids_rev,
9390                 .capsrc_nids = alc883_capsrc_nids_rev,
9391                 .dig_out_nid = ALC883_DIGOUT_NID,
9392                 .dig_in_nid = ALC883_DIGIN_NID,
9393                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9394                 .channel_mode = alc883_4ST_8ch_modes,
9395                 .need_dac_fix = 1,
9396                 .input_mux = &alc883_capture_source,
9397                 .unsol_event = alc883_targa_unsol_event,
9398                 .setup = alc882_targa_setup,
9399                 .init_hook = alc882_targa_automute,
9400         },
9401         [ALC883_ACER] = {
9402                 .mixers = { alc883_base_mixer },
9403                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9404                  * and the headphone jack.  Turn this on and rely on the
9405                  * standard mute methods whenever the user wants to turn
9406                  * these outputs off.
9407                  */
9408                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9409                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9410                 .dac_nids = alc883_dac_nids,
9411                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9412                 .channel_mode = alc883_3ST_2ch_modes,
9413                 .input_mux = &alc883_capture_source,
9414         },
9415         [ALC883_ACER_ASPIRE] = {
9416                 .mixers = { alc883_acer_aspire_mixer },
9417                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9418                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9419                 .dac_nids = alc883_dac_nids,
9420                 .dig_out_nid = ALC883_DIGOUT_NID,
9421                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9422                 .channel_mode = alc883_3ST_2ch_modes,
9423                 .input_mux = &alc883_capture_source,
9424                 .unsol_event = alc_automute_amp_unsol_event,
9425                 .setup = alc883_acer_aspire_setup,
9426                 .init_hook = alc_automute_amp,
9427         },
9428         [ALC888_ACER_ASPIRE_4930G] = {
9429                 .mixers = { alc888_base_mixer,
9430                                 alc883_chmode_mixer },
9431                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9432                                 alc888_acer_aspire_4930g_verbs },
9433                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9434                 .dac_nids = alc883_dac_nids,
9435                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9436                 .adc_nids = alc883_adc_nids_rev,
9437                 .capsrc_nids = alc883_capsrc_nids_rev,
9438                 .dig_out_nid = ALC883_DIGOUT_NID,
9439                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9440                 .channel_mode = alc883_3ST_6ch_modes,
9441                 .need_dac_fix = 1,
9442                 .num_mux_defs =
9443                         ARRAY_SIZE(alc888_2_capture_sources),
9444                 .input_mux = alc888_2_capture_sources,
9445                 .unsol_event = alc_automute_amp_unsol_event,
9446                 .setup = alc888_acer_aspire_4930g_setup,
9447                 .init_hook = alc_automute_amp,
9448         },
9449         [ALC888_ACER_ASPIRE_6530G] = {
9450                 .mixers = { alc888_acer_aspire_6530_mixer },
9451                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9452                                 alc888_acer_aspire_6530g_verbs },
9453                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9454                 .dac_nids = alc883_dac_nids,
9455                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9456                 .adc_nids = alc883_adc_nids_rev,
9457                 .capsrc_nids = alc883_capsrc_nids_rev,
9458                 .dig_out_nid = ALC883_DIGOUT_NID,
9459                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9460                 .channel_mode = alc883_3ST_2ch_modes,
9461                 .num_mux_defs =
9462                         ARRAY_SIZE(alc888_2_capture_sources),
9463                 .input_mux = alc888_acer_aspire_6530_sources,
9464                 .unsol_event = alc_automute_amp_unsol_event,
9465                 .setup = alc888_acer_aspire_6530g_setup,
9466                 .init_hook = alc_automute_amp,
9467         },
9468         [ALC888_ACER_ASPIRE_8930G] = {
9469                 .mixers = { alc888_base_mixer,
9470                                 alc883_chmode_mixer },
9471                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9472                                 alc889_acer_aspire_8930g_verbs },
9473                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9474                 .dac_nids = alc883_dac_nids,
9475                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9476                 .adc_nids = alc889_adc_nids,
9477                 .capsrc_nids = alc889_capsrc_nids,
9478                 .dig_out_nid = ALC883_DIGOUT_NID,
9479                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9480                 .channel_mode = alc883_3ST_6ch_modes,
9481                 .need_dac_fix = 1,
9482                 .const_channel_count = 6,
9483                 .num_mux_defs =
9484                         ARRAY_SIZE(alc889_capture_sources),
9485                 .input_mux = alc889_capture_sources,
9486                 .unsol_event = alc_automute_amp_unsol_event,
9487                 .setup = alc889_acer_aspire_8930g_setup,
9488                 .init_hook = alc_automute_amp,
9489         },
9490         [ALC888_ACER_ASPIRE_7730G] = {
9491                 .mixers = { alc883_3ST_6ch_mixer,
9492                                 alc883_chmode_mixer },
9493                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9494                                 alc888_acer_aspire_7730G_verbs },
9495                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9496                 .dac_nids = alc883_dac_nids,
9497                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9498                 .adc_nids = alc883_adc_nids_rev,
9499                 .capsrc_nids = alc883_capsrc_nids_rev,
9500                 .dig_out_nid = ALC883_DIGOUT_NID,
9501                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9502                 .channel_mode = alc883_3ST_6ch_modes,
9503                 .need_dac_fix = 1,
9504                 .const_channel_count = 6,
9505                 .input_mux = &alc883_capture_source,
9506                 .unsol_event = alc_automute_amp_unsol_event,
9507                 .setup = alc888_acer_aspire_6530g_setup,
9508                 .init_hook = alc_automute_amp,
9509         },
9510         [ALC883_MEDION] = {
9511                 .mixers = { alc883_fivestack_mixer,
9512                             alc883_chmode_mixer },
9513                 .init_verbs = { alc883_init_verbs,
9514                                 alc883_medion_eapd_verbs },
9515                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9516                 .dac_nids = alc883_dac_nids,
9517                 .adc_nids = alc883_adc_nids_alt,
9518                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9519                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9520                 .channel_mode = alc883_sixstack_modes,
9521                 .input_mux = &alc883_capture_source,
9522         },
9523         [ALC883_MEDION_MD2] = {
9524                 .mixers = { alc883_medion_md2_mixer},
9525                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9526                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9527                 .dac_nids = alc883_dac_nids,
9528                 .dig_out_nid = ALC883_DIGOUT_NID,
9529                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9530                 .channel_mode = alc883_3ST_2ch_modes,
9531                 .input_mux = &alc883_capture_source,
9532                 .unsol_event = alc_automute_amp_unsol_event,
9533                 .setup = alc883_medion_md2_setup,
9534                 .init_hook = alc_automute_amp,
9535         },
9536         [ALC883_LAPTOP_EAPD] = {
9537                 .mixers = { alc883_base_mixer },
9538                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9539                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9540                 .dac_nids = alc883_dac_nids,
9541                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9542                 .channel_mode = alc883_3ST_2ch_modes,
9543                 .input_mux = &alc883_capture_source,
9544         },
9545         [ALC883_CLEVO_M540R] = {
9546                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9547                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9548                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9549                 .dac_nids = alc883_dac_nids,
9550                 .dig_out_nid = ALC883_DIGOUT_NID,
9551                 .dig_in_nid = ALC883_DIGIN_NID,
9552                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9553                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9554                 .need_dac_fix = 1,
9555                 .input_mux = &alc883_capture_source,
9556                 /* This machine has the hardware HP auto-muting, thus
9557                  * we need no software mute via unsol event
9558                  */
9559         },
9560         [ALC883_CLEVO_M720] = {
9561                 .mixers = { alc883_clevo_m720_mixer },
9562                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9563                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9564                 .dac_nids = alc883_dac_nids,
9565                 .dig_out_nid = ALC883_DIGOUT_NID,
9566                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9567                 .channel_mode = alc883_3ST_2ch_modes,
9568                 .input_mux = &alc883_capture_source,
9569                 .unsol_event = alc883_clevo_m720_unsol_event,
9570                 .setup = alc883_clevo_m720_setup,
9571                 .init_hook = alc883_clevo_m720_init_hook,
9572         },
9573         [ALC883_LENOVO_101E_2ch] = {
9574                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9575                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9576                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9577                 .dac_nids = alc883_dac_nids,
9578                 .adc_nids = alc883_adc_nids_alt,
9579                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9580                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9581                 .channel_mode = alc883_3ST_2ch_modes,
9582                 .input_mux = &alc883_lenovo_101e_capture_source,
9583                 .unsol_event = alc883_lenovo_101e_unsol_event,
9584                 .init_hook = alc883_lenovo_101e_all_automute,
9585         },
9586         [ALC883_LENOVO_NB0763] = {
9587                 .mixers = { alc883_lenovo_nb0763_mixer },
9588                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9589                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9590                 .dac_nids = alc883_dac_nids,
9591                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9592                 .channel_mode = alc883_3ST_2ch_modes,
9593                 .need_dac_fix = 1,
9594                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9595                 .unsol_event = alc_automute_amp_unsol_event,
9596                 .setup = alc883_medion_md2_setup,
9597                 .init_hook = alc_automute_amp,
9598         },
9599         [ALC888_LENOVO_MS7195_DIG] = {
9600                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9601                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9602                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9603                 .dac_nids = alc883_dac_nids,
9604                 .dig_out_nid = ALC883_DIGOUT_NID,
9605                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9606                 .channel_mode = alc883_3ST_6ch_modes,
9607                 .need_dac_fix = 1,
9608                 .input_mux = &alc883_capture_source,
9609                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9610                 .init_hook = alc888_lenovo_ms7195_front_automute,
9611         },
9612         [ALC883_HAIER_W66] = {
9613                 .mixers = { alc883_targa_2ch_mixer},
9614                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9615                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9616                 .dac_nids = alc883_dac_nids,
9617                 .dig_out_nid = ALC883_DIGOUT_NID,
9618                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9619                 .channel_mode = alc883_3ST_2ch_modes,
9620                 .input_mux = &alc883_capture_source,
9621                 .unsol_event = alc_automute_amp_unsol_event,
9622                 .setup = alc883_haier_w66_setup,
9623                 .init_hook = alc_automute_amp,
9624         },
9625         [ALC888_3ST_HP] = {
9626                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9627                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9628                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9629                 .dac_nids = alc883_dac_nids,
9630                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9631                 .channel_mode = alc888_3st_hp_modes,
9632                 .need_dac_fix = 1,
9633                 .input_mux = &alc883_capture_source,
9634                 .unsol_event = alc_automute_amp_unsol_event,
9635                 .setup = alc888_3st_hp_setup,
9636                 .init_hook = alc_automute_amp,
9637         },
9638         [ALC888_6ST_DELL] = {
9639                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9640                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9641                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9642                 .dac_nids = alc883_dac_nids,
9643                 .dig_out_nid = ALC883_DIGOUT_NID,
9644                 .dig_in_nid = ALC883_DIGIN_NID,
9645                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9646                 .channel_mode = alc883_sixstack_modes,
9647                 .input_mux = &alc883_capture_source,
9648                 .unsol_event = alc_automute_amp_unsol_event,
9649                 .setup = alc888_6st_dell_setup,
9650                 .init_hook = alc_automute_amp,
9651         },
9652         [ALC883_MITAC] = {
9653                 .mixers = { alc883_mitac_mixer },
9654                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9655                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9656                 .dac_nids = alc883_dac_nids,
9657                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9658                 .channel_mode = alc883_3ST_2ch_modes,
9659                 .input_mux = &alc883_capture_source,
9660                 .unsol_event = alc_automute_amp_unsol_event,
9661                 .setup = alc883_mitac_setup,
9662                 .init_hook = alc_automute_amp,
9663         },
9664         [ALC883_FUJITSU_PI2515] = {
9665                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9666                 .init_verbs = { alc883_init_verbs,
9667                                 alc883_2ch_fujitsu_pi2515_verbs},
9668                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9669                 .dac_nids = alc883_dac_nids,
9670                 .dig_out_nid = ALC883_DIGOUT_NID,
9671                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9672                 .channel_mode = alc883_3ST_2ch_modes,
9673                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9674                 .unsol_event = alc_automute_amp_unsol_event,
9675                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9676                 .init_hook = alc_automute_amp,
9677         },
9678         [ALC888_FUJITSU_XA3530] = {
9679                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9680                 .init_verbs = { alc883_init_verbs,
9681                         alc888_fujitsu_xa3530_verbs },
9682                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9683                 .dac_nids = alc883_dac_nids,
9684                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9685                 .adc_nids = alc883_adc_nids_rev,
9686                 .capsrc_nids = alc883_capsrc_nids_rev,
9687                 .dig_out_nid = ALC883_DIGOUT_NID,
9688                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9689                 .channel_mode = alc888_4ST_8ch_intel_modes,
9690                 .num_mux_defs =
9691                         ARRAY_SIZE(alc888_2_capture_sources),
9692                 .input_mux = alc888_2_capture_sources,
9693                 .unsol_event = alc_automute_amp_unsol_event,
9694                 .setup = alc888_fujitsu_xa3530_setup,
9695                 .init_hook = alc_automute_amp,
9696         },
9697         [ALC888_LENOVO_SKY] = {
9698                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9699                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9700                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9701                 .dac_nids = alc883_dac_nids,
9702                 .dig_out_nid = ALC883_DIGOUT_NID,
9703                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9704                 .channel_mode = alc883_sixstack_modes,
9705                 .need_dac_fix = 1,
9706                 .input_mux = &alc883_lenovo_sky_capture_source,
9707                 .unsol_event = alc_automute_amp_unsol_event,
9708                 .setup = alc888_lenovo_sky_setup,
9709                 .init_hook = alc_automute_amp,
9710         },
9711         [ALC888_ASUS_M90V] = {
9712                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9713                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9714                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9715                 .dac_nids = alc883_dac_nids,
9716                 .dig_out_nid = ALC883_DIGOUT_NID,
9717                 .dig_in_nid = ALC883_DIGIN_NID,
9718                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9719                 .channel_mode = alc883_3ST_6ch_modes,
9720                 .need_dac_fix = 1,
9721                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9722                 .unsol_event = alc_sku_unsol_event,
9723                 .setup = alc883_mode2_setup,
9724                 .init_hook = alc_inithook,
9725         },
9726         [ALC888_ASUS_EEE1601] = {
9727                 .mixers = { alc883_asus_eee1601_mixer },
9728                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9729                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9730                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9731                 .dac_nids = alc883_dac_nids,
9732                 .dig_out_nid = ALC883_DIGOUT_NID,
9733                 .dig_in_nid = ALC883_DIGIN_NID,
9734                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9735                 .channel_mode = alc883_3ST_2ch_modes,
9736                 .need_dac_fix = 1,
9737                 .input_mux = &alc883_asus_eee1601_capture_source,
9738                 .unsol_event = alc_sku_unsol_event,
9739                 .init_hook = alc883_eee1601_inithook,
9740         },
9741         [ALC1200_ASUS_P5Q] = {
9742                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9743                 .init_verbs = { alc883_init_verbs },
9744                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9745                 .dac_nids = alc883_dac_nids,
9746                 .dig_out_nid = ALC1200_DIGOUT_NID,
9747                 .dig_in_nid = ALC883_DIGIN_NID,
9748                 .slave_dig_outs = alc1200_slave_dig_outs,
9749                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9750                 .channel_mode = alc883_sixstack_modes,
9751                 .input_mux = &alc883_capture_source,
9752         },
9753         [ALC889A_MB31] = {
9754                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9755                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9756                         alc880_gpio1_init_verbs },
9757                 .adc_nids = alc883_adc_nids,
9758                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9759                 .dac_nids = alc883_dac_nids,
9760                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9761                 .channel_mode = alc889A_mb31_6ch_modes,
9762                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9763                 .input_mux = &alc889A_mb31_capture_source,
9764                 .dig_out_nid = ALC883_DIGOUT_NID,
9765                 .unsol_event = alc889A_mb31_unsol_event,
9766                 .init_hook = alc889A_mb31_automute,
9767         },
9768         [ALC883_SONY_VAIO_TT] = {
9769                 .mixers = { alc883_vaiott_mixer },
9770                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9771                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9772                 .dac_nids = alc883_dac_nids,
9773                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9774                 .channel_mode = alc883_3ST_2ch_modes,
9775                 .input_mux = &alc883_capture_source,
9776                 .unsol_event = alc_automute_amp_unsol_event,
9777                 .setup = alc883_vaiott_setup,
9778                 .init_hook = alc_automute_amp,
9779         },
9780 };
9781
9782
9783 /*
9784  * Pin config fixes
9785  */
9786 enum {
9787         PINFIX_ABIT_AW9D_MAX
9788 };
9789
9790 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9791         { 0x15, 0x01080104 }, /* side */
9792         { 0x16, 0x01011012 }, /* rear */
9793         { 0x17, 0x01016011 }, /* clfe */
9794         { }
9795 };
9796
9797 static const struct alc_fixup alc882_fixups[] = {
9798         [PINFIX_ABIT_AW9D_MAX] = {
9799                 .pins = alc882_abit_aw9d_pinfix
9800         },
9801 };
9802
9803 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9804         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9805         {}
9806 };
9807
9808 /*
9809  * BIOS auto configuration
9810  */
9811 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9812                                                 const struct auto_pin_cfg *cfg)
9813 {
9814         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9815 }
9816
9817 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9818                                               hda_nid_t nid, int pin_type,
9819                                               int dac_idx)
9820 {
9821         /* set as output */
9822         struct alc_spec *spec = codec->spec;
9823         int idx;
9824
9825         alc_set_pin_output(codec, nid, pin_type);
9826         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9827                 idx = 4;
9828         else
9829                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9830         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9831
9832 }
9833
9834 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9835 {
9836         struct alc_spec *spec = codec->spec;
9837         int i;
9838
9839         for (i = 0; i <= HDA_SIDE; i++) {
9840                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9841                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9842                 if (nid)
9843                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9844                                                           i);
9845         }
9846 }
9847
9848 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9849 {
9850         struct alc_spec *spec = codec->spec;
9851         hda_nid_t pin;
9852
9853         pin = spec->autocfg.hp_pins[0];
9854         if (pin) /* connect to front */
9855                 /* use dac 0 */
9856                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9857         pin = spec->autocfg.speaker_pins[0];
9858         if (pin)
9859                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9860 }
9861
9862 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9863 {
9864         struct alc_spec *spec = codec->spec;
9865         int i;
9866
9867         for (i = 0; i < AUTO_PIN_LAST; i++) {
9868                 hda_nid_t nid = spec->autocfg.input_pins[i];
9869                 if (!nid)
9870                         continue;
9871                 alc_set_input_pin(codec, nid, i);
9872                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9873                         snd_hda_codec_write(codec, nid, 0,
9874                                             AC_VERB_SET_AMP_GAIN_MUTE,
9875                                             AMP_OUT_MUTE);
9876         }
9877 }
9878
9879 static void alc882_auto_init_input_src(struct hda_codec *codec)
9880 {
9881         struct alc_spec *spec = codec->spec;
9882         int c;
9883
9884         for (c = 0; c < spec->num_adc_nids; c++) {
9885                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9886                 hda_nid_t nid = spec->capsrc_nids[c];
9887                 unsigned int mux_idx;
9888                 const struct hda_input_mux *imux;
9889                 int conns, mute, idx, item;
9890
9891                 conns = snd_hda_get_connections(codec, nid, conn_list,
9892                                                 ARRAY_SIZE(conn_list));
9893                 if (conns < 0)
9894                         continue;
9895                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9896                 imux = &spec->input_mux[mux_idx];
9897                 for (idx = 0; idx < conns; idx++) {
9898                         /* if the current connection is the selected one,
9899                          * unmute it as default - otherwise mute it
9900                          */
9901                         mute = AMP_IN_MUTE(idx);
9902                         for (item = 0; item < imux->num_items; item++) {
9903                                 if (imux->items[item].index == idx) {
9904                                         if (spec->cur_mux[c] == item)
9905                                                 mute = AMP_IN_UNMUTE(idx);
9906                                         break;
9907                                 }
9908                         }
9909                         /* check if we have a selector or mixer
9910                          * we could check for the widget type instead, but
9911                          * just check for Amp-In presence (in case of mixer
9912                          * without amp-in there is something wrong, this
9913                          * function shouldn't be used or capsrc nid is wrong)
9914                          */
9915                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9916                                 snd_hda_codec_write(codec, nid, 0,
9917                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9918                                                     mute);
9919                         else if (mute != AMP_IN_MUTE(idx))
9920                                 snd_hda_codec_write(codec, nid, 0,
9921                                                     AC_VERB_SET_CONNECT_SEL,
9922                                                     idx);
9923                 }
9924         }
9925 }
9926
9927 /* add mic boosts if needed */
9928 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9929 {
9930         struct alc_spec *spec = codec->spec;
9931         int err;
9932         hda_nid_t nid;
9933
9934         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9935         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9936                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9937                                   "Mic Boost",
9938                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9939                 if (err < 0)
9940                         return err;
9941         }
9942         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9943         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9944                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9945                                   "Front Mic Boost",
9946                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9947                 if (err < 0)
9948                         return err;
9949         }
9950         return 0;
9951 }
9952
9953 /* almost identical with ALC880 parser... */
9954 static int alc882_parse_auto_config(struct hda_codec *codec)
9955 {
9956         struct alc_spec *spec = codec->spec;
9957         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
9958         int i, err;
9959
9960         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9961                                            alc882_ignore);
9962         if (err < 0)
9963                 return err;
9964         if (!spec->autocfg.line_outs)
9965                 return 0; /* can't find valid BIOS pin config */
9966
9967         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
9968         if (err < 0)
9969                 return err;
9970         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
9971         if (err < 0)
9972                 return err;
9973         err = alc880_auto_create_extra_out(spec,
9974                                            spec->autocfg.speaker_pins[0],
9975                                            "Speaker");
9976         if (err < 0)
9977                 return err;
9978         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9979                                            "Headphone");
9980         if (err < 0)
9981                 return err;
9982         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
9983         if (err < 0)
9984                 return err;
9985
9986         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9987
9988         /* check multiple SPDIF-out (for recent codecs) */
9989         for (i = 0; i < spec->autocfg.dig_outs; i++) {
9990                 hda_nid_t dig_nid;
9991                 err = snd_hda_get_connections(codec,
9992                                               spec->autocfg.dig_out_pins[i],
9993                                               &dig_nid, 1);
9994                 if (err < 0)
9995                         continue;
9996                 if (!i)
9997                         spec->multiout.dig_out_nid = dig_nid;
9998                 else {
9999                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10000                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10001                                 break;
10002                         spec->slave_dig_outs[i - 1] = dig_nid;
10003                 }
10004         }
10005         if (spec->autocfg.dig_in_pin)
10006                 spec->dig_in_nid = ALC880_DIGIN_NID;
10007
10008         if (spec->kctls.list)
10009                 add_mixer(spec, spec->kctls.list);
10010
10011         add_verb(spec, alc883_auto_init_verbs);
10012         /* if ADC 0x07 is available, initialize it, too */
10013         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10014                 add_verb(spec, alc882_adc1_init_verbs);
10015
10016         spec->num_mux_defs = 1;
10017         spec->input_mux = &spec->private_imux[0];
10018
10019         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
10020
10021         err = alc_auto_add_mic_boost(codec);
10022         if (err < 0)
10023                 return err;
10024
10025         return 1; /* config found */
10026 }
10027
10028 /* additional initialization for auto-configuration model */
10029 static void alc882_auto_init(struct hda_codec *codec)
10030 {
10031         struct alc_spec *spec = codec->spec;
10032         alc882_auto_init_multi_out(codec);
10033         alc882_auto_init_hp_out(codec);
10034         alc882_auto_init_analog_input(codec);
10035         alc882_auto_init_input_src(codec);
10036         if (spec->unsol_event)
10037                 alc_inithook(codec);
10038 }
10039
10040 static int patch_alc882(struct hda_codec *codec)
10041 {
10042         struct alc_spec *spec;
10043         int err, board_config;
10044
10045         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10046         if (spec == NULL)
10047                 return -ENOMEM;
10048
10049         codec->spec = spec;
10050
10051         switch (codec->vendor_id) {
10052         case 0x10ec0882:
10053         case 0x10ec0885:
10054                 break;
10055         default:
10056                 /* ALC883 and variants */
10057                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10058                 break;
10059         }
10060
10061         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10062                                                   alc882_models,
10063                                                   alc882_cfg_tbl);
10064
10065         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10066                 board_config = snd_hda_check_board_codec_sid_config(codec,
10067                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10068
10069         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10070                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10071                        codec->chip_name);
10072                 board_config = ALC882_AUTO;
10073         }
10074
10075         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10076
10077         if (board_config == ALC882_AUTO) {
10078                 /* automatic parse from the BIOS config */
10079                 err = alc882_parse_auto_config(codec);
10080                 if (err < 0) {
10081                         alc_free(codec);
10082                         return err;
10083                 } else if (!err) {
10084                         printk(KERN_INFO
10085                                "hda_codec: Cannot set up configuration "
10086                                "from BIOS.  Using base mode...\n");
10087                         board_config = ALC882_3ST_DIG;
10088                 }
10089         }
10090
10091         err = snd_hda_attach_beep_device(codec, 0x1);
10092         if (err < 0) {
10093                 alc_free(codec);
10094                 return err;
10095         }
10096
10097         if (board_config != ALC882_AUTO)
10098                 setup_preset(codec, &alc882_presets[board_config]);
10099
10100         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10101         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10102         /* FIXME: setup DAC5 */
10103         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10104         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10105
10106         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10107         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10108
10109         if (codec->vendor_id == 0x10ec0888)
10110                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10111
10112         if (!spec->adc_nids && spec->input_mux) {
10113                 int i, j;
10114                 spec->num_adc_nids = 0;
10115                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10116                         const struct hda_input_mux *imux = spec->input_mux;
10117                         hda_nid_t cap;
10118                         hda_nid_t items[16];
10119                         hda_nid_t nid = alc882_adc_nids[i];
10120                         unsigned int wcap = get_wcaps(codec, nid);
10121                         /* get type */
10122                         wcap = get_wcaps_type(wcap);
10123                         if (wcap != AC_WID_AUD_IN)
10124                                 continue;
10125                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10126                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10127                         if (err < 0)
10128                                 continue;
10129                         err = snd_hda_get_connections(codec, cap, items,
10130                                                       ARRAY_SIZE(items));
10131                         if (err < 0)
10132                                 continue;
10133                         for (j = 0; j < imux->num_items; j++)
10134                                 if (imux->items[j].index >= err)
10135                                         break;
10136                         if (j < imux->num_items)
10137                                 continue;
10138                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10139                         spec->num_adc_nids++;
10140                 }
10141                 spec->adc_nids = spec->private_adc_nids;
10142                 spec->capsrc_nids = spec->private_capsrc_nids;
10143         }
10144
10145         set_capture_mixer(codec);
10146         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10147
10148         spec->vmaster_nid = 0x0c;
10149
10150         codec->patch_ops = alc_patch_ops;
10151         if (board_config == ALC882_AUTO)
10152                 spec->init_hook = alc882_auto_init;
10153 #ifdef CONFIG_SND_HDA_POWER_SAVE
10154         if (!spec->loopback.amplist)
10155                 spec->loopback.amplist = alc882_loopbacks;
10156 #endif
10157         codec->proc_widget_hook = print_realtek_coef;
10158
10159         return 0;
10160 }
10161
10162
10163 /*
10164  * ALC262 support
10165  */
10166
10167 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10168 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10169
10170 #define alc262_dac_nids         alc260_dac_nids
10171 #define alc262_adc_nids         alc882_adc_nids
10172 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10173 #define alc262_capsrc_nids      alc882_capsrc_nids
10174 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10175
10176 #define alc262_modes            alc260_modes
10177 #define alc262_capture_source   alc882_capture_source
10178
10179 static hda_nid_t alc262_dmic_adc_nids[1] = {
10180         /* ADC0 */
10181         0x09
10182 };
10183
10184 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10185
10186 static struct snd_kcontrol_new alc262_base_mixer[] = {
10187         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10188         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10189         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10190         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10191         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10192         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10193         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10194         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10195         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10196         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10197         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10198         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10199         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10200         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10201         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10202         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10203         { } /* end */
10204 };
10205
10206 /* update HP, line and mono-out pins according to the master switch */
10207 static void alc262_hp_master_update(struct hda_codec *codec)
10208 {
10209         struct alc_spec *spec = codec->spec;
10210         int val = spec->master_sw;
10211
10212         /* HP & line-out */
10213         snd_hda_codec_write_cache(codec, 0x1b, 0,
10214                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10215                                   val ? PIN_HP : 0);
10216         snd_hda_codec_write_cache(codec, 0x15, 0,
10217                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10218                                   val ? PIN_HP : 0);
10219         /* mono (speaker) depending on the HP jack sense */
10220         val = val && !spec->jack_present;
10221         snd_hda_codec_write_cache(codec, 0x16, 0,
10222                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10223                                   val ? PIN_OUT : 0);
10224 }
10225
10226 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10227 {
10228         struct alc_spec *spec = codec->spec;
10229
10230         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10231         alc262_hp_master_update(codec);
10232 }
10233
10234 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10235 {
10236         if ((res >> 26) != ALC880_HP_EVENT)
10237                 return;
10238         alc262_hp_bpc_automute(codec);
10239 }
10240
10241 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10242 {
10243         struct alc_spec *spec = codec->spec;
10244
10245         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10246         alc262_hp_master_update(codec);
10247 }
10248
10249 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10250                                            unsigned int res)
10251 {
10252         if ((res >> 26) != ALC880_HP_EVENT)
10253                 return;
10254         alc262_hp_wildwest_automute(codec);
10255 }
10256
10257 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10258
10259 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10260                                    struct snd_ctl_elem_value *ucontrol)
10261 {
10262         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10263         struct alc_spec *spec = codec->spec;
10264         int val = !!*ucontrol->value.integer.value;
10265
10266         if (val == spec->master_sw)
10267                 return 0;
10268         spec->master_sw = val;
10269         alc262_hp_master_update(codec);
10270         return 1;
10271 }
10272
10273 #define ALC262_HP_MASTER_SWITCH                                 \
10274         {                                                       \
10275                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10276                 .name = "Master Playback Switch",               \
10277                 .info = snd_ctl_boolean_mono_info,              \
10278                 .get = alc262_hp_master_sw_get,                 \
10279                 .put = alc262_hp_master_sw_put,                 \
10280         }, \
10281         {                                                       \
10282                 .iface = NID_MAPPING,                           \
10283                 .name = "Master Playback Switch",               \
10284                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
10285         }
10286
10287
10288 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10289         ALC262_HP_MASTER_SWITCH,
10290         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10291         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10292         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10293         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10294                               HDA_OUTPUT),
10295         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10296                             HDA_OUTPUT),
10297         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10298         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10299         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10300         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10301         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10302         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10303         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10304         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10305         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10306         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10307         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10308         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10309         { } /* end */
10310 };
10311
10312 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10313         ALC262_HP_MASTER_SWITCH,
10314         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10315         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10316         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10317         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10318         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10319                               HDA_OUTPUT),
10320         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10321                             HDA_OUTPUT),
10322         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10323         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10324         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10325         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10326         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10327         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10328         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10329         { } /* end */
10330 };
10331
10332 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10333         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10334         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10335         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10336         { } /* end */
10337 };
10338
10339 /* mute/unmute internal speaker according to the hp jack and mute state */
10340 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10341 {
10342         struct alc_spec *spec = codec->spec;
10343
10344         spec->autocfg.hp_pins[0] = 0x15;
10345         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
10346 }
10347
10348 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10349         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10350         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10351         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10352         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10353         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10354         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10355         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10356         { } /* end */
10357 };
10358
10359 static struct hda_verb alc262_hp_t5735_verbs[] = {
10360         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10361         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10362
10363         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10364         { }
10365 };
10366
10367 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10368         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10369         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10370         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10371         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10372         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10373         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10374         { } /* end */
10375 };
10376
10377 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10378         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10379         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10380         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10381         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10382         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10383         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10384         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10385         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10386         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10387         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10388         {}
10389 };
10390
10391 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10392         .num_items = 1,
10393         .items = {
10394                 { "Line", 0x1 },
10395         },
10396 };
10397
10398 /* bind hp and internal speaker mute (with plug check) as master switch */
10399 static void alc262_hippo_master_update(struct hda_codec *codec)
10400 {
10401         struct alc_spec *spec = codec->spec;
10402         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10403         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10404         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10405         unsigned int mute;
10406
10407         /* HP */
10408         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10409         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10410                                  HDA_AMP_MUTE, mute);
10411         /* mute internal speaker per jack sense */
10412         if (spec->jack_present)
10413                 mute = HDA_AMP_MUTE;
10414         if (line_nid)
10415                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10416                                          HDA_AMP_MUTE, mute);
10417         if (speaker_nid && speaker_nid != line_nid)
10418                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10419                                          HDA_AMP_MUTE, mute);
10420 }
10421
10422 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10423
10424 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10425                                       struct snd_ctl_elem_value *ucontrol)
10426 {
10427         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10428         struct alc_spec *spec = codec->spec;
10429         int val = !!*ucontrol->value.integer.value;
10430
10431         if (val == spec->master_sw)
10432                 return 0;
10433         spec->master_sw = val;
10434         alc262_hippo_master_update(codec);
10435         return 1;
10436 }
10437
10438 #define ALC262_HIPPO_MASTER_SWITCH                              \
10439         {                                                       \
10440                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10441                 .name = "Master Playback Switch",               \
10442                 .info = snd_ctl_boolean_mono_info,              \
10443                 .get = alc262_hippo_master_sw_get,              \
10444                 .put = alc262_hippo_master_sw_put,              \
10445         },                                                      \
10446         {                                                       \
10447                 .iface = NID_MAPPING,                           \
10448                 .name = "Master Playback Switch",               \
10449                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
10450                              (SUBDEV_SPEAKER(0) << 16), \
10451         }
10452
10453 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10454         ALC262_HIPPO_MASTER_SWITCH,
10455         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10456         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10457         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10458         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10459         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10460         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10461         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10462         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10463         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10464         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10465         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10466         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10467         { } /* end */
10468 };
10469
10470 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10471         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10472         ALC262_HIPPO_MASTER_SWITCH,
10473         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10474         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10475         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10476         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10477         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10478         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10479         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10480         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10481         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10482         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10483         { } /* end */
10484 };
10485
10486 /* mute/unmute internal speaker according to the hp jack and mute state */
10487 static void alc262_hippo_automute(struct hda_codec *codec)
10488 {
10489         struct alc_spec *spec = codec->spec;
10490         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10491
10492         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10493         alc262_hippo_master_update(codec);
10494 }
10495
10496 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10497 {
10498         if ((res >> 26) != ALC880_HP_EVENT)
10499                 return;
10500         alc262_hippo_automute(codec);
10501 }
10502
10503 static void alc262_hippo_setup(struct hda_codec *codec)
10504 {
10505         struct alc_spec *spec = codec->spec;
10506
10507         spec->autocfg.hp_pins[0] = 0x15;
10508         spec->autocfg.speaker_pins[0] = 0x14;
10509 }
10510
10511 static void alc262_hippo1_setup(struct hda_codec *codec)
10512 {
10513         struct alc_spec *spec = codec->spec;
10514
10515         spec->autocfg.hp_pins[0] = 0x1b;
10516         spec->autocfg.speaker_pins[0] = 0x14;
10517 }
10518
10519
10520 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10521         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10522         ALC262_HIPPO_MASTER_SWITCH,
10523         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10524         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10525         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10526         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10527         { } /* end */
10528 };
10529
10530 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10531         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10532         ALC262_HIPPO_MASTER_SWITCH,
10533         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10534         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10535         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10536         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10537         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10538         { } /* end */
10539 };
10540
10541 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10542         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10543         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10544         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10545         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10546         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10547         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10548         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10549         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10550         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10551         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10552         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10553         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10554         { } /* end */
10555 };
10556
10557 static struct hda_verb alc262_tyan_verbs[] = {
10558         /* Headphone automute */
10559         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10560         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10561         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10562
10563         /* P11 AUX_IN, white 4-pin connector */
10564         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10565         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10566         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10567         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10568
10569         {}
10570 };
10571
10572 /* unsolicited event for HP jack sensing */
10573 static void alc262_tyan_setup(struct hda_codec *codec)
10574 {
10575         struct alc_spec *spec = codec->spec;
10576
10577         spec->autocfg.hp_pins[0] = 0x1b;
10578         spec->autocfg.speaker_pins[0] = 0x15;
10579 }
10580
10581
10582 #define alc262_capture_mixer            alc882_capture_mixer
10583 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10584
10585 /*
10586  * generic initialization of ADC, input mixers and output mixers
10587  */
10588 static struct hda_verb alc262_init_verbs[] = {
10589         /*
10590          * Unmute ADC0-2 and set the default input to mic-in
10591          */
10592         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10593         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10594         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10595         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10596         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10597         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10598
10599         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10600          * mixer widget
10601          * Note: PASD motherboards uses the Line In 2 as the input for
10602          * front panel mic (mic 2)
10603          */
10604         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10605         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10606         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10607         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10608         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10609         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10610
10611         /*
10612          * Set up output mixers (0x0c - 0x0e)
10613          */
10614         /* set vol=0 to output mixers */
10615         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10616         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10617         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10618         /* set up input amps for analog loopback */
10619         /* Amp Indices: DAC = 0, mixer = 1 */
10620         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10621         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10622         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10623         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10624         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10625         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10626
10627         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10628         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10629         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10630         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10631         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10632         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10633
10634         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10635         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10636         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10637         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10638         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10639
10640         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10641         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10642
10643         /* FIXME: use matrix-type input source selection */
10644         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10645         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10646         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10647         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10648         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10649         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10650         /* Input mixer2 */
10651         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10652         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10653         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10654         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10655         /* Input mixer3 */
10656         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10657         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10658         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10659         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10660
10661         { }
10662 };
10663
10664 static struct hda_verb alc262_eapd_verbs[] = {
10665         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10666         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10667         { }
10668 };
10669
10670 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10671         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10672         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10673         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10674
10675         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10676         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10677         {}
10678 };
10679
10680 static struct hda_verb alc262_sony_unsol_verbs[] = {
10681         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10682         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10683         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10684
10685         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10686         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10687         {}
10688 };
10689
10690 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10691         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10692         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10693         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10694         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10695         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10696         { } /* end */
10697 };
10698
10699 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10700         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10701         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10702         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10703         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10704         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10705         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10706         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10707         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10708         {}
10709 };
10710
10711 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10712 {
10713         struct alc_spec *spec = codec->spec;
10714
10715         spec->autocfg.hp_pins[0] = 0x15;
10716         spec->autocfg.speaker_pins[0] = 0x14;
10717         spec->ext_mic.pin = 0x18;
10718         spec->ext_mic.mux_idx = 0;
10719         spec->int_mic.pin = 0x12;
10720         spec->int_mic.mux_idx = 9;
10721         spec->auto_mic = 1;
10722 }
10723
10724 /*
10725  * nec model
10726  *  0x15 = headphone
10727  *  0x16 = internal speaker
10728  *  0x18 = external mic
10729  */
10730
10731 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10732         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10733         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10734
10735         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10736         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10737         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10738
10739         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10740         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10741         { } /* end */
10742 };
10743
10744 static struct hda_verb alc262_nec_verbs[] = {
10745         /* Unmute Speaker */
10746         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10747
10748         /* Headphone */
10749         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10750         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10751
10752         /* External mic to headphone */
10753         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10754         /* External mic to speaker */
10755         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10756         {}
10757 };
10758
10759 /*
10760  * fujitsu model
10761  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10762  *  0x1b = port replicator headphone out
10763  */
10764
10765 #define ALC_HP_EVENT    0x37
10766
10767 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10768         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10769         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10770         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10771         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10772         {}
10773 };
10774
10775 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10776         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10777         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10778         {}
10779 };
10780
10781 static struct hda_input_mux alc262_fujitsu_capture_source = {
10782         .num_items = 3,
10783         .items = {
10784                 { "Mic", 0x0 },
10785                 { "Int Mic", 0x1 },
10786                 { "CD", 0x4 },
10787         },
10788 };
10789
10790 static struct hda_input_mux alc262_HP_capture_source = {
10791         .num_items = 5,
10792         .items = {
10793                 { "Mic", 0x0 },
10794                 { "Front Mic", 0x1 },
10795                 { "Line", 0x2 },
10796                 { "CD", 0x4 },
10797                 { "AUX IN", 0x6 },
10798         },
10799 };
10800
10801 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10802         .num_items = 4,
10803         .items = {
10804                 { "Mic", 0x0 },
10805                 { "Front Mic", 0x2 },
10806                 { "Line", 0x1 },
10807                 { "CD", 0x4 },
10808         },
10809 };
10810
10811 /* mute/unmute internal speaker according to the hp jacks and mute state */
10812 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10813 {
10814         struct alc_spec *spec = codec->spec;
10815         unsigned int mute;
10816
10817         if (force || !spec->sense_updated) {
10818                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
10819                                      snd_hda_jack_detect(codec, 0x1b);
10820                 spec->sense_updated = 1;
10821         }
10822         /* unmute internal speaker only if both HPs are unplugged and
10823          * master switch is on
10824          */
10825         if (spec->jack_present)
10826                 mute = HDA_AMP_MUTE;
10827         else
10828                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10829         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10830                                  HDA_AMP_MUTE, mute);
10831 }
10832
10833 /* unsolicited event for HP jack sensing */
10834 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10835                                        unsigned int res)
10836 {
10837         if ((res >> 26) != ALC_HP_EVENT)
10838                 return;
10839         alc262_fujitsu_automute(codec, 1);
10840 }
10841
10842 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10843 {
10844         alc262_fujitsu_automute(codec, 1);
10845 }
10846
10847 /* bind volumes of both NID 0x0c and 0x0d */
10848 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10849         .ops = &snd_hda_bind_vol,
10850         .values = {
10851                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10852                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10853                 0
10854         },
10855 };
10856
10857 /* mute/unmute internal speaker according to the hp jack and mute state */
10858 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10859 {
10860         struct alc_spec *spec = codec->spec;
10861         unsigned int mute;
10862
10863         if (force || !spec->sense_updated) {
10864                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10865                 spec->sense_updated = 1;
10866         }
10867         if (spec->jack_present) {
10868                 /* mute internal speaker */
10869                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10870                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10871                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10872                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10873         } else {
10874                 /* unmute internal speaker if necessary */
10875                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10876                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10877                                          HDA_AMP_MUTE, mute);
10878                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10879                                          HDA_AMP_MUTE, mute);
10880         }
10881 }
10882
10883 /* unsolicited event for HP jack sensing */
10884 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10885                                        unsigned int res)
10886 {
10887         if ((res >> 26) != ALC_HP_EVENT)
10888                 return;
10889         alc262_lenovo_3000_automute(codec, 1);
10890 }
10891
10892 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10893                                   int dir, int idx, long *valp)
10894 {
10895         int i, change = 0;
10896
10897         for (i = 0; i < 2; i++, valp++)
10898                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10899                                                    HDA_AMP_MUTE,
10900                                                    *valp ? 0 : HDA_AMP_MUTE);
10901         return change;
10902 }
10903
10904 /* bind hp and internal speaker mute (with plug check) */
10905 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10906                                          struct snd_ctl_elem_value *ucontrol)
10907 {
10908         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10909         long *valp = ucontrol->value.integer.value;
10910         int change;
10911
10912         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10913         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10914         if (change)
10915                 alc262_fujitsu_automute(codec, 0);
10916         return change;
10917 }
10918
10919 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10920         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10921         {
10922                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10923                 .name = "Master Playback Switch",
10924                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
10925                 .info = snd_hda_mixer_amp_switch_info,
10926                 .get = snd_hda_mixer_amp_switch_get,
10927                 .put = alc262_fujitsu_master_sw_put,
10928                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10929         },
10930         {
10931                 .iface = NID_MAPPING,
10932                 .name = "Master Playback Switch",
10933                 .private_value = 0x1b,
10934         },
10935         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10936         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10937         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10938         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10939         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10940         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10941         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10942         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10943         { } /* end */
10944 };
10945
10946 /* bind hp and internal speaker mute (with plug check) */
10947 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10948                                          struct snd_ctl_elem_value *ucontrol)
10949 {
10950         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10951         long *valp = ucontrol->value.integer.value;
10952         int change;
10953
10954         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10955         if (change)
10956                 alc262_lenovo_3000_automute(codec, 0);
10957         return change;
10958 }
10959
10960 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10961         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10962         {
10963                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10964                 .name = "Master Playback Switch",
10965                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x1b,
10966                 .info = snd_hda_mixer_amp_switch_info,
10967                 .get = snd_hda_mixer_amp_switch_get,
10968                 .put = alc262_lenovo_3000_master_sw_put,
10969                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10970         },
10971         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10972         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10973         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10974         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10976         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10977         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10978         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10979         { } /* end */
10980 };
10981
10982 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10983         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10984         ALC262_HIPPO_MASTER_SWITCH,
10985         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10986         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10987         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10988         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10989         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10990         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10991         { } /* end */
10992 };
10993
10994 /* additional init verbs for Benq laptops */
10995 static struct hda_verb alc262_EAPD_verbs[] = {
10996         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10997         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10998         {}
10999 };
11000
11001 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11002         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11003         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11004
11005         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11006         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11007         {}
11008 };
11009
11010 /* Samsung Q1 Ultra Vista model setup */
11011 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11012         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11013         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11014         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11015         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11016         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11017         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11018         { } /* end */
11019 };
11020
11021 static struct hda_verb alc262_ultra_verbs[] = {
11022         /* output mixer */
11023         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11024         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11025         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11026         /* speaker */
11027         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11028         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11029         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11030         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11031         /* HP */
11032         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11033         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11034         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11035         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11036         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11037         /* internal mic */
11038         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11039         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11040         /* ADC, choose mic */
11041         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11042         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11043         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11044         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11045         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11046         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11047         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11048         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11049         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11050         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11051         {}
11052 };
11053
11054 /* mute/unmute internal speaker according to the hp jack and mute state */
11055 static void alc262_ultra_automute(struct hda_codec *codec)
11056 {
11057         struct alc_spec *spec = codec->spec;
11058         unsigned int mute;
11059
11060         mute = 0;
11061         /* auto-mute only when HP is used as HP */
11062         if (!spec->cur_mux[0]) {
11063                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11064                 if (spec->jack_present)
11065                         mute = HDA_AMP_MUTE;
11066         }
11067         /* mute/unmute internal speaker */
11068         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11069                                  HDA_AMP_MUTE, mute);
11070         /* mute/unmute HP */
11071         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11072                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11073 }
11074
11075 /* unsolicited event for HP jack sensing */
11076 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11077                                        unsigned int res)
11078 {
11079         if ((res >> 26) != ALC880_HP_EVENT)
11080                 return;
11081         alc262_ultra_automute(codec);
11082 }
11083
11084 static struct hda_input_mux alc262_ultra_capture_source = {
11085         .num_items = 2,
11086         .items = {
11087                 { "Mic", 0x1 },
11088                 { "Headphone", 0x7 },
11089         },
11090 };
11091
11092 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11093                                      struct snd_ctl_elem_value *ucontrol)
11094 {
11095         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11096         struct alc_spec *spec = codec->spec;
11097         int ret;
11098
11099         ret = alc_mux_enum_put(kcontrol, ucontrol);
11100         if (!ret)
11101                 return 0;
11102         /* reprogram the HP pin as mic or HP according to the input source */
11103         snd_hda_codec_write_cache(codec, 0x15, 0,
11104                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11105                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11106         alc262_ultra_automute(codec); /* mute/unmute HP */
11107         return ret;
11108 }
11109
11110 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11111         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11112         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11113         {
11114                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11115                 .name = "Capture Source",
11116                 .info = alc_mux_enum_info,
11117                 .get = alc_mux_enum_get,
11118                 .put = alc262_ultra_mux_enum_put,
11119         },
11120         {
11121                 .iface = NID_MAPPING,
11122                 .name = "Capture Source",
11123                 .private_value = 0x15,
11124         },
11125         { } /* end */
11126 };
11127
11128 /* We use two mixers depending on the output pin; 0x16 is a mono output
11129  * and thus it's bound with a different mixer.
11130  * This function returns which mixer amp should be used.
11131  */
11132 static int alc262_check_volbit(hda_nid_t nid)
11133 {
11134         if (!nid)
11135                 return 0;
11136         else if (nid == 0x16)
11137                 return 2;
11138         else
11139                 return 1;
11140 }
11141
11142 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11143                                   const char *pfx, int *vbits)
11144 {
11145         unsigned long val;
11146         int vbit;
11147
11148         vbit = alc262_check_volbit(nid);
11149         if (!vbit)
11150                 return 0;
11151         if (*vbits & vbit) /* a volume control for this mixer already there */
11152                 return 0;
11153         *vbits |= vbit;
11154         if (vbit == 2)
11155                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11156         else
11157                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11158         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11159 }
11160
11161 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11162                                  const char *pfx)
11163 {
11164         unsigned long val;
11165
11166         if (!nid)
11167                 return 0;
11168         if (nid == 0x16)
11169                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11170         else
11171                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11172         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11173 }
11174
11175 /* add playback controls from the parsed DAC table */
11176 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11177                                              const struct auto_pin_cfg *cfg)
11178 {
11179         const char *pfx;
11180         int vbits;
11181         int err;
11182
11183         spec->multiout.num_dacs = 1;    /* only use one dac */
11184         spec->multiout.dac_nids = spec->private_dac_nids;
11185         spec->multiout.dac_nids[0] = 2;
11186
11187         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11188                 pfx = "Master";
11189         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11190                 pfx = "Speaker";
11191         else
11192                 pfx = "Front";
11193         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11194         if (err < 0)
11195                 return err;
11196         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11197         if (err < 0)
11198                 return err;
11199         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11200         if (err < 0)
11201                 return err;
11202
11203         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11204                 alc262_check_volbit(cfg->speaker_pins[0]) |
11205                 alc262_check_volbit(cfg->hp_pins[0]);
11206         if (vbits == 1 || vbits == 2)
11207                 pfx = "Master"; /* only one mixer is used */
11208         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11209                 pfx = "Speaker";
11210         else
11211                 pfx = "Front";
11212         vbits = 0;
11213         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11214         if (err < 0)
11215                 return err;
11216         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11217                                      &vbits);
11218         if (err < 0)
11219                 return err;
11220         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11221                                      &vbits);
11222         if (err < 0)
11223                 return err;
11224         return 0;
11225 }
11226
11227 #define alc262_auto_create_input_ctls \
11228         alc880_auto_create_input_ctls
11229
11230 /*
11231  * generic initialization of ADC, input mixers and output mixers
11232  */
11233 static struct hda_verb alc262_volume_init_verbs[] = {
11234         /*
11235          * Unmute ADC0-2 and set the default input to mic-in
11236          */
11237         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11238         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11239         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11240         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11241         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11242         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11243
11244         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11245          * mixer widget
11246          * Note: PASD motherboards uses the Line In 2 as the input for
11247          * front panel mic (mic 2)
11248          */
11249         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11250         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11251         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11252         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11253         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11254         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11255
11256         /*
11257          * Set up output mixers (0x0c - 0x0f)
11258          */
11259         /* set vol=0 to output mixers */
11260         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11261         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11262         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11263
11264         /* set up input amps for analog loopback */
11265         /* Amp Indices: DAC = 0, mixer = 1 */
11266         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11267         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11268         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11269         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11270         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11271         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11272
11273         /* FIXME: use matrix-type input source selection */
11274         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11275         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11276         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11277         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11278         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11279         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11280         /* Input mixer2 */
11281         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11282         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11283         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11284         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11285         /* Input mixer3 */
11286         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11287         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11288         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11289         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11290
11291         { }
11292 };
11293
11294 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11295         /*
11296          * Unmute ADC0-2 and set the default input to mic-in
11297          */
11298         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11299         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11300         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11301         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11302         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11303         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11304
11305         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11306          * mixer widget
11307          * Note: PASD motherboards uses the Line In 2 as the input for
11308          * front panel mic (mic 2)
11309          */
11310         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11311         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11312         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11313         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11314         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11315         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11316         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11317         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11318
11319         /*
11320          * Set up output mixers (0x0c - 0x0e)
11321          */
11322         /* set vol=0 to output mixers */
11323         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11324         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11325         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11326
11327         /* set up input amps for analog loopback */
11328         /* Amp Indices: DAC = 0, mixer = 1 */
11329         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11330         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11331         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11332         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11333         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11334         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11335
11336         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11337         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11338         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11339
11340         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11341         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11342
11343         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11344         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11345
11346         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11347         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11348         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11349         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11350         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11351
11352         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11353         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11354         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11355         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11356         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11357         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11358
11359
11360         /* FIXME: use matrix-type input source selection */
11361         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11362         /* Input mixer1: only unmute Mic */
11363         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11364         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11365         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11366         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11367         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11368         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11371         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11372         /* Input mixer2 */
11373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11375         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11376         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11377         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11378         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11379         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11380         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11381         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11382         /* Input mixer3 */
11383         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11384         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11385         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11386         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11387         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11388         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11389         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11390         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11391         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11392
11393         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11394
11395         { }
11396 };
11397
11398 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11399         /*
11400          * Unmute ADC0-2 and set the default input to mic-in
11401          */
11402         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11403         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11404         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11405         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11406         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11407         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11408
11409         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11410          * mixer widget
11411          * Note: PASD motherboards uses the Line In 2 as the input for front
11412          * panel mic (mic 2)
11413          */
11414         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11415         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11416         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11417         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11418         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11419         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11420         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11421         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11422         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11423         /*
11424          * Set up output mixers (0x0c - 0x0e)
11425          */
11426         /* set vol=0 to output mixers */
11427         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11428         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11429         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11430
11431         /* set up input amps for analog loopback */
11432         /* Amp Indices: DAC = 0, mixer = 1 */
11433         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11434         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11435         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11436         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11437         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11438         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11439
11440
11441         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11442         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11443         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11444         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11445         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11446         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11447         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11448
11449         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11450         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11451
11452         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11453         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11454
11455         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11456         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11457         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11458         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11459         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11460         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11461
11462         /* FIXME: use matrix-type input source selection */
11463         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11464         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11465         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11466         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11467         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11468         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11469         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11470         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11471         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11472         /* Input mixer2 */
11473         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11474         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11475         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11476         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11477         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11478         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11479         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11480         /* Input mixer3 */
11481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11482         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11483         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11484         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11485         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11486         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11487         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11488
11489         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11490
11491         { }
11492 };
11493
11494 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11495
11496         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11497         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11498         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11499
11500         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11501         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11502         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11503         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11504
11505         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11506         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11507         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11508         {}
11509 };
11510
11511
11512 #ifdef CONFIG_SND_HDA_POWER_SAVE
11513 #define alc262_loopbacks        alc880_loopbacks
11514 #endif
11515
11516 /* pcm configuration: identical with ALC880 */
11517 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11518 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11519 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11520 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11521
11522 /*
11523  * BIOS auto configuration
11524  */
11525 static int alc262_parse_auto_config(struct hda_codec *codec)
11526 {
11527         struct alc_spec *spec = codec->spec;
11528         int err;
11529         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11530
11531         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11532                                            alc262_ignore);
11533         if (err < 0)
11534                 return err;
11535         if (!spec->autocfg.line_outs) {
11536                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11537                         spec->multiout.max_channels = 2;
11538                         spec->no_analog = 1;
11539                         goto dig_only;
11540                 }
11541                 return 0; /* can't find valid BIOS pin config */
11542         }
11543         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11544         if (err < 0)
11545                 return err;
11546         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11547         if (err < 0)
11548                 return err;
11549
11550         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11551
11552  dig_only:
11553         if (spec->autocfg.dig_outs) {
11554                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11555                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11556         }
11557         if (spec->autocfg.dig_in_pin)
11558                 spec->dig_in_nid = ALC262_DIGIN_NID;
11559
11560         if (spec->kctls.list)
11561                 add_mixer(spec, spec->kctls.list);
11562
11563         add_verb(spec, alc262_volume_init_verbs);
11564         spec->num_mux_defs = 1;
11565         spec->input_mux = &spec->private_imux[0];
11566
11567         err = alc_auto_add_mic_boost(codec);
11568         if (err < 0)
11569                 return err;
11570
11571         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11572
11573         return 1;
11574 }
11575
11576 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11577 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11578 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11579 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11580
11581
11582 /* init callback for auto-configuration model -- overriding the default init */
11583 static void alc262_auto_init(struct hda_codec *codec)
11584 {
11585         struct alc_spec *spec = codec->spec;
11586         alc262_auto_init_multi_out(codec);
11587         alc262_auto_init_hp_out(codec);
11588         alc262_auto_init_analog_input(codec);
11589         alc262_auto_init_input_src(codec);
11590         if (spec->unsol_event)
11591                 alc_inithook(codec);
11592 }
11593
11594 /*
11595  * configuration and preset
11596  */
11597 static const char *alc262_models[ALC262_MODEL_LAST] = {
11598         [ALC262_BASIC]          = "basic",
11599         [ALC262_HIPPO]          = "hippo",
11600         [ALC262_HIPPO_1]        = "hippo_1",
11601         [ALC262_FUJITSU]        = "fujitsu",
11602         [ALC262_HP_BPC]         = "hp-bpc",
11603         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11604         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11605         [ALC262_HP_RP5700]      = "hp-rp5700",
11606         [ALC262_BENQ_ED8]       = "benq",
11607         [ALC262_BENQ_T31]       = "benq-t31",
11608         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11609         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11610         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11611         [ALC262_ULTRA]          = "ultra",
11612         [ALC262_LENOVO_3000]    = "lenovo-3000",
11613         [ALC262_NEC]            = "nec",
11614         [ALC262_TYAN]           = "tyan",
11615         [ALC262_AUTO]           = "auto",
11616 };
11617
11618 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11619         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11620         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11621         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11622                            ALC262_HP_BPC),
11623         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11624                            ALC262_HP_BPC),
11625         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11626                            ALC262_HP_BPC),
11627         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11628         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11629         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11630         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11631         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11632         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11633         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11634         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11635         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11636         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11637         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11638         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11639                       ALC262_HP_TC_T5735),
11640         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11641         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11642         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11643         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11644         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11645         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11646         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11647         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11648 #if 0 /* disable the quirk since model=auto works better in recent versions */
11649         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11650                            ALC262_SONY_ASSAMD),
11651 #endif
11652         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11653                       ALC262_TOSHIBA_RX1),
11654         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11655         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11656         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11657         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11658         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11659                            ALC262_ULTRA),
11660         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11661         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11662         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11663         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11664         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11665         {}
11666 };
11667
11668 static struct alc_config_preset alc262_presets[] = {
11669         [ALC262_BASIC] = {
11670                 .mixers = { alc262_base_mixer },
11671                 .init_verbs = { alc262_init_verbs },
11672                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11673                 .dac_nids = alc262_dac_nids,
11674                 .hp_nid = 0x03,
11675                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11676                 .channel_mode = alc262_modes,
11677                 .input_mux = &alc262_capture_source,
11678         },
11679         [ALC262_HIPPO] = {
11680                 .mixers = { alc262_hippo_mixer },
11681                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11682                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11683                 .dac_nids = alc262_dac_nids,
11684                 .hp_nid = 0x03,
11685                 .dig_out_nid = ALC262_DIGOUT_NID,
11686                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11687                 .channel_mode = alc262_modes,
11688                 .input_mux = &alc262_capture_source,
11689                 .unsol_event = alc262_hippo_unsol_event,
11690                 .setup = alc262_hippo_setup,
11691                 .init_hook = alc262_hippo_automute,
11692         },
11693         [ALC262_HIPPO_1] = {
11694                 .mixers = { alc262_hippo1_mixer },
11695                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11696                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11697                 .dac_nids = alc262_dac_nids,
11698                 .hp_nid = 0x02,
11699                 .dig_out_nid = ALC262_DIGOUT_NID,
11700                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11701                 .channel_mode = alc262_modes,
11702                 .input_mux = &alc262_capture_source,
11703                 .unsol_event = alc262_hippo_unsol_event,
11704                 .setup = alc262_hippo1_setup,
11705                 .init_hook = alc262_hippo_automute,
11706         },
11707         [ALC262_FUJITSU] = {
11708                 .mixers = { alc262_fujitsu_mixer },
11709                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11710                                 alc262_fujitsu_unsol_verbs },
11711                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11712                 .dac_nids = alc262_dac_nids,
11713                 .hp_nid = 0x03,
11714                 .dig_out_nid = ALC262_DIGOUT_NID,
11715                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11716                 .channel_mode = alc262_modes,
11717                 .input_mux = &alc262_fujitsu_capture_source,
11718                 .unsol_event = alc262_fujitsu_unsol_event,
11719                 .init_hook = alc262_fujitsu_init_hook,
11720         },
11721         [ALC262_HP_BPC] = {
11722                 .mixers = { alc262_HP_BPC_mixer },
11723                 .init_verbs = { alc262_HP_BPC_init_verbs },
11724                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11725                 .dac_nids = alc262_dac_nids,
11726                 .hp_nid = 0x03,
11727                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11728                 .channel_mode = alc262_modes,
11729                 .input_mux = &alc262_HP_capture_source,
11730                 .unsol_event = alc262_hp_bpc_unsol_event,
11731                 .init_hook = alc262_hp_bpc_automute,
11732         },
11733         [ALC262_HP_BPC_D7000_WF] = {
11734                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11735                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11736                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11737                 .dac_nids = alc262_dac_nids,
11738                 .hp_nid = 0x03,
11739                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11740                 .channel_mode = alc262_modes,
11741                 .input_mux = &alc262_HP_D7000_capture_source,
11742                 .unsol_event = alc262_hp_wildwest_unsol_event,
11743                 .init_hook = alc262_hp_wildwest_automute,
11744         },
11745         [ALC262_HP_BPC_D7000_WL] = {
11746                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11747                             alc262_HP_BPC_WildWest_option_mixer },
11748                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11749                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11750                 .dac_nids = alc262_dac_nids,
11751                 .hp_nid = 0x03,
11752                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11753                 .channel_mode = alc262_modes,
11754                 .input_mux = &alc262_HP_D7000_capture_source,
11755                 .unsol_event = alc262_hp_wildwest_unsol_event,
11756                 .init_hook = alc262_hp_wildwest_automute,
11757         },
11758         [ALC262_HP_TC_T5735] = {
11759                 .mixers = { alc262_hp_t5735_mixer },
11760                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11761                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11762                 .dac_nids = alc262_dac_nids,
11763                 .hp_nid = 0x03,
11764                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11765                 .channel_mode = alc262_modes,
11766                 .input_mux = &alc262_capture_source,
11767                 .unsol_event = alc_automute_amp_unsol_event,
11768                 .setup = alc262_hp_t5735_setup,
11769                 .init_hook = alc_automute_amp,
11770         },
11771         [ALC262_HP_RP5700] = {
11772                 .mixers = { alc262_hp_rp5700_mixer },
11773                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11774                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11775                 .dac_nids = alc262_dac_nids,
11776                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11777                 .channel_mode = alc262_modes,
11778                 .input_mux = &alc262_hp_rp5700_capture_source,
11779         },
11780         [ALC262_BENQ_ED8] = {
11781                 .mixers = { alc262_base_mixer },
11782                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11783                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11784                 .dac_nids = alc262_dac_nids,
11785                 .hp_nid = 0x03,
11786                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11787                 .channel_mode = alc262_modes,
11788                 .input_mux = &alc262_capture_source,
11789         },
11790         [ALC262_SONY_ASSAMD] = {
11791                 .mixers = { alc262_sony_mixer },
11792                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11793                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11794                 .dac_nids = alc262_dac_nids,
11795                 .hp_nid = 0x02,
11796                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11797                 .channel_mode = alc262_modes,
11798                 .input_mux = &alc262_capture_source,
11799                 .unsol_event = alc262_hippo_unsol_event,
11800                 .setup = alc262_hippo_setup,
11801                 .init_hook = alc262_hippo_automute,
11802         },
11803         [ALC262_BENQ_T31] = {
11804                 .mixers = { alc262_benq_t31_mixer },
11805                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11806                                 alc_hp15_unsol_verbs },
11807                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11808                 .dac_nids = alc262_dac_nids,
11809                 .hp_nid = 0x03,
11810                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11811                 .channel_mode = alc262_modes,
11812                 .input_mux = &alc262_capture_source,
11813                 .unsol_event = alc262_hippo_unsol_event,
11814                 .setup = alc262_hippo_setup,
11815                 .init_hook = alc262_hippo_automute,
11816         },
11817         [ALC262_ULTRA] = {
11818                 .mixers = { alc262_ultra_mixer },
11819                 .cap_mixer = alc262_ultra_capture_mixer,
11820                 .init_verbs = { alc262_ultra_verbs },
11821                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11822                 .dac_nids = alc262_dac_nids,
11823                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11824                 .channel_mode = alc262_modes,
11825                 .input_mux = &alc262_ultra_capture_source,
11826                 .adc_nids = alc262_adc_nids, /* ADC0 */
11827                 .capsrc_nids = alc262_capsrc_nids,
11828                 .num_adc_nids = 1, /* single ADC */
11829                 .unsol_event = alc262_ultra_unsol_event,
11830                 .init_hook = alc262_ultra_automute,
11831         },
11832         [ALC262_LENOVO_3000] = {
11833                 .mixers = { alc262_lenovo_3000_mixer },
11834                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11835                                 alc262_lenovo_3000_unsol_verbs },
11836                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11837                 .dac_nids = alc262_dac_nids,
11838                 .hp_nid = 0x03,
11839                 .dig_out_nid = ALC262_DIGOUT_NID,
11840                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11841                 .channel_mode = alc262_modes,
11842                 .input_mux = &alc262_fujitsu_capture_source,
11843                 .unsol_event = alc262_lenovo_3000_unsol_event,
11844         },
11845         [ALC262_NEC] = {
11846                 .mixers = { alc262_nec_mixer },
11847                 .init_verbs = { alc262_nec_verbs },
11848                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11849                 .dac_nids = alc262_dac_nids,
11850                 .hp_nid = 0x03,
11851                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11852                 .channel_mode = alc262_modes,
11853                 .input_mux = &alc262_capture_source,
11854         },
11855         [ALC262_TOSHIBA_S06] = {
11856                 .mixers = { alc262_toshiba_s06_mixer },
11857                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11858                                                         alc262_eapd_verbs },
11859                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11860                 .capsrc_nids = alc262_dmic_capsrc_nids,
11861                 .dac_nids = alc262_dac_nids,
11862                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11863                 .num_adc_nids = 1, /* single ADC */
11864                 .dig_out_nid = ALC262_DIGOUT_NID,
11865                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11866                 .channel_mode = alc262_modes,
11867                 .unsol_event = alc_sku_unsol_event,
11868                 .setup = alc262_toshiba_s06_setup,
11869                 .init_hook = alc_inithook,
11870         },
11871         [ALC262_TOSHIBA_RX1] = {
11872                 .mixers = { alc262_toshiba_rx1_mixer },
11873                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11874                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11875                 .dac_nids = alc262_dac_nids,
11876                 .hp_nid = 0x03,
11877                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11878                 .channel_mode = alc262_modes,
11879                 .input_mux = &alc262_capture_source,
11880                 .unsol_event = alc262_hippo_unsol_event,
11881                 .setup = alc262_hippo_setup,
11882                 .init_hook = alc262_hippo_automute,
11883         },
11884         [ALC262_TYAN] = {
11885                 .mixers = { alc262_tyan_mixer },
11886                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11887                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11888                 .dac_nids = alc262_dac_nids,
11889                 .hp_nid = 0x02,
11890                 .dig_out_nid = ALC262_DIGOUT_NID,
11891                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11892                 .channel_mode = alc262_modes,
11893                 .input_mux = &alc262_capture_source,
11894                 .unsol_event = alc_automute_amp_unsol_event,
11895                 .setup = alc262_tyan_setup,
11896                 .init_hook = alc_automute_amp,
11897         },
11898 };
11899
11900 static int patch_alc262(struct hda_codec *codec)
11901 {
11902         struct alc_spec *spec;
11903         int board_config;
11904         int err;
11905
11906         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11907         if (spec == NULL)
11908                 return -ENOMEM;
11909
11910         codec->spec = spec;
11911 #if 0
11912         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11913          * under-run
11914          */
11915         {
11916         int tmp;
11917         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11918         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11919         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11920         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11921         }
11922 #endif
11923
11924         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11925
11926         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11927                                                   alc262_models,
11928                                                   alc262_cfg_tbl);
11929
11930         if (board_config < 0) {
11931                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11932                        codec->chip_name);
11933                 board_config = ALC262_AUTO;
11934         }
11935
11936         if (board_config == ALC262_AUTO) {
11937                 /* automatic parse from the BIOS config */
11938                 err = alc262_parse_auto_config(codec);
11939                 if (err < 0) {
11940                         alc_free(codec);
11941                         return err;
11942                 } else if (!err) {
11943                         printk(KERN_INFO
11944                                "hda_codec: Cannot set up configuration "
11945                                "from BIOS.  Using base mode...\n");
11946                         board_config = ALC262_BASIC;
11947                 }
11948         }
11949
11950         if (!spec->no_analog) {
11951                 err = snd_hda_attach_beep_device(codec, 0x1);
11952                 if (err < 0) {
11953                         alc_free(codec);
11954                         return err;
11955                 }
11956         }
11957
11958         if (board_config != ALC262_AUTO)
11959                 setup_preset(codec, &alc262_presets[board_config]);
11960
11961         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11962         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11963
11964         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11965         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11966
11967         if (!spec->adc_nids && spec->input_mux) {
11968                 int i;
11969                 /* check whether the digital-mic has to be supported */
11970                 for (i = 0; i < spec->input_mux->num_items; i++) {
11971                         if (spec->input_mux->items[i].index >= 9)
11972                                 break;
11973                 }
11974                 if (i < spec->input_mux->num_items) {
11975                         /* use only ADC0 */
11976                         spec->adc_nids = alc262_dmic_adc_nids;
11977                         spec->num_adc_nids = 1;
11978                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11979                 } else {
11980                         /* all analog inputs */
11981                         /* check whether NID 0x07 is valid */
11982                         unsigned int wcap = get_wcaps(codec, 0x07);
11983
11984                         /* get type */
11985                         wcap = get_wcaps_type(wcap);
11986                         if (wcap != AC_WID_AUD_IN) {
11987                                 spec->adc_nids = alc262_adc_nids_alt;
11988                                 spec->num_adc_nids =
11989                                         ARRAY_SIZE(alc262_adc_nids_alt);
11990                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11991                         } else {
11992                                 spec->adc_nids = alc262_adc_nids;
11993                                 spec->num_adc_nids =
11994                                         ARRAY_SIZE(alc262_adc_nids);
11995                                 spec->capsrc_nids = alc262_capsrc_nids;
11996                         }
11997                 }
11998         }
11999         if (!spec->cap_mixer && !spec->no_analog)
12000                 set_capture_mixer(codec);
12001         if (!spec->no_analog)
12002                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12003
12004         spec->vmaster_nid = 0x0c;
12005
12006         codec->patch_ops = alc_patch_ops;
12007         if (board_config == ALC262_AUTO)
12008                 spec->init_hook = alc262_auto_init;
12009 #ifdef CONFIG_SND_HDA_POWER_SAVE
12010         if (!spec->loopback.amplist)
12011                 spec->loopback.amplist = alc262_loopbacks;
12012 #endif
12013         codec->proc_widget_hook = print_realtek_coef;
12014
12015         return 0;
12016 }
12017
12018 /*
12019  *  ALC268 channel source setting (2 channel)
12020  */
12021 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12022 #define alc268_modes            alc260_modes
12023
12024 static hda_nid_t alc268_dac_nids[2] = {
12025         /* front, hp */
12026         0x02, 0x03
12027 };
12028
12029 static hda_nid_t alc268_adc_nids[2] = {
12030         /* ADC0-1 */
12031         0x08, 0x07
12032 };
12033
12034 static hda_nid_t alc268_adc_nids_alt[1] = {
12035         /* ADC0 */
12036         0x08
12037 };
12038
12039 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12040
12041 static struct snd_kcontrol_new alc268_base_mixer[] = {
12042         /* output mixer control */
12043         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12044         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12045         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12046         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12047         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12048         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12049         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12050         { }
12051 };
12052
12053 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12054         /* output mixer control */
12055         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12056         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12057         ALC262_HIPPO_MASTER_SWITCH,
12058         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12059         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12060         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12061         { }
12062 };
12063
12064 /* bind Beep switches of both NID 0x0f and 0x10 */
12065 static struct hda_bind_ctls alc268_bind_beep_sw = {
12066         .ops = &snd_hda_bind_sw,
12067         .values = {
12068                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12069                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12070                 0
12071         },
12072 };
12073
12074 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12075         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12076         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12077         { }
12078 };
12079
12080 static struct hda_verb alc268_eapd_verbs[] = {
12081         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12082         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12083         { }
12084 };
12085
12086 /* Toshiba specific */
12087 static struct hda_verb alc268_toshiba_verbs[] = {
12088         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12089         { } /* end */
12090 };
12091
12092 /* Acer specific */
12093 /* bind volumes of both NID 0x02 and 0x03 */
12094 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12095         .ops = &snd_hda_bind_vol,
12096         .values = {
12097                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12098                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12099                 0
12100         },
12101 };
12102
12103 /* mute/unmute internal speaker according to the hp jack and mute state */
12104 static void alc268_acer_automute(struct hda_codec *codec, int force)
12105 {
12106         struct alc_spec *spec = codec->spec;
12107         unsigned int mute;
12108
12109         if (force || !spec->sense_updated) {
12110                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12111                 spec->sense_updated = 1;
12112         }
12113         if (spec->jack_present)
12114                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12115         else /* unmute internal speaker if necessary */
12116                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12117         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12118                                  HDA_AMP_MUTE, mute);
12119 }
12120
12121
12122 /* bind hp and internal speaker mute (with plug check) */
12123 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12124                                      struct snd_ctl_elem_value *ucontrol)
12125 {
12126         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12127         long *valp = ucontrol->value.integer.value;
12128         int change;
12129
12130         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12131         if (change)
12132                 alc268_acer_automute(codec, 0);
12133         return change;
12134 }
12135
12136 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12137         /* output mixer control */
12138         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12139         {
12140                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12141                 .name = "Master Playback Switch",
12142                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
12143                 .info = snd_hda_mixer_amp_switch_info,
12144                 .get = snd_hda_mixer_amp_switch_get,
12145                 .put = alc268_acer_master_sw_put,
12146                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12147         },
12148         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12149         { }
12150 };
12151
12152 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12153         /* output mixer control */
12154         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12155         {
12156                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12157                 .name = "Master Playback Switch",
12158                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
12159                 .info = snd_hda_mixer_amp_switch_info,
12160                 .get = snd_hda_mixer_amp_switch_get,
12161                 .put = alc268_acer_master_sw_put,
12162                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12163         },
12164         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12165         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12166         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12167         { }
12168 };
12169
12170 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12171         /* output mixer control */
12172         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12173         {
12174                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12175                 .name = "Master Playback Switch",
12176                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
12177                 .info = snd_hda_mixer_amp_switch_info,
12178                 .get = snd_hda_mixer_amp_switch_get,
12179                 .put = alc268_acer_master_sw_put,
12180                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12181         },
12182         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12183         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12184         { }
12185 };
12186
12187 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12188         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12189         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12190         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12191         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12192         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12193         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12194         { }
12195 };
12196
12197 static struct hda_verb alc268_acer_verbs[] = {
12198         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12199         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12200         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12201         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12202         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12203         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12204         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12205         { }
12206 };
12207
12208 /* unsolicited event for HP jack sensing */
12209 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12210 #define alc268_toshiba_setup            alc262_hippo_setup
12211 #define alc268_toshiba_automute         alc262_hippo_automute
12212
12213 static void alc268_acer_unsol_event(struct hda_codec *codec,
12214                                        unsigned int res)
12215 {
12216         if ((res >> 26) != ALC880_HP_EVENT)
12217                 return;
12218         alc268_acer_automute(codec, 1);
12219 }
12220
12221 static void alc268_acer_init_hook(struct hda_codec *codec)
12222 {
12223         alc268_acer_automute(codec, 1);
12224 }
12225
12226 /* toggle speaker-output according to the hp-jack state */
12227 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12228 {
12229         unsigned int present;
12230         unsigned char bits;
12231
12232         present = snd_hda_jack_detect(codec, 0x15);
12233         bits = present ? AMP_IN_MUTE(0) : 0;
12234         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12235                                 AMP_IN_MUTE(0), bits);
12236         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12237                                 AMP_IN_MUTE(0), bits);
12238 }
12239
12240 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12241                                     unsigned int res)
12242 {
12243         switch (res >> 26) {
12244         case ALC880_HP_EVENT:
12245                 alc268_aspire_one_speaker_automute(codec);
12246                 break;
12247         case ALC880_MIC_EVENT:
12248                 alc_mic_automute(codec);
12249                 break;
12250         }
12251 }
12252
12253 static void alc268_acer_lc_setup(struct hda_codec *codec)
12254 {
12255         struct alc_spec *spec = codec->spec;
12256         spec->ext_mic.pin = 0x18;
12257         spec->ext_mic.mux_idx = 0;
12258         spec->int_mic.pin = 0x12;
12259         spec->int_mic.mux_idx = 6;
12260         spec->auto_mic = 1;
12261 }
12262
12263 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12264 {
12265         alc268_aspire_one_speaker_automute(codec);
12266         alc_mic_automute(codec);
12267 }
12268
12269 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12270         /* output mixer control */
12271         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12272         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12273         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12274         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12275         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12276         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12277         { }
12278 };
12279
12280 static struct hda_verb alc268_dell_verbs[] = {
12281         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12282         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12283         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12284         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12285         { }
12286 };
12287
12288 /* mute/unmute internal speaker according to the hp jack and mute state */
12289 static void alc268_dell_setup(struct hda_codec *codec)
12290 {
12291         struct alc_spec *spec = codec->spec;
12292
12293         spec->autocfg.hp_pins[0] = 0x15;
12294         spec->autocfg.speaker_pins[0] = 0x14;
12295         spec->ext_mic.pin = 0x18;
12296         spec->ext_mic.mux_idx = 0;
12297         spec->int_mic.pin = 0x19;
12298         spec->int_mic.mux_idx = 1;
12299         spec->auto_mic = 1;
12300 }
12301
12302 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12303         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12304         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12305         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12306         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12307         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12308         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12309         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12310         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12311         { }
12312 };
12313
12314 static struct hda_verb alc267_quanta_il1_verbs[] = {
12315         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12316         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12317         { }
12318 };
12319
12320 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12321 {
12322         struct alc_spec *spec = codec->spec;
12323         spec->autocfg.hp_pins[0] = 0x15;
12324         spec->autocfg.speaker_pins[0] = 0x14;
12325         spec->ext_mic.pin = 0x18;
12326         spec->ext_mic.mux_idx = 0;
12327         spec->int_mic.pin = 0x19;
12328         spec->int_mic.mux_idx = 1;
12329         spec->auto_mic = 1;
12330 }
12331
12332 /*
12333  * generic initialization of ADC, input mixers and output mixers
12334  */
12335 static struct hda_verb alc268_base_init_verbs[] = {
12336         /* Unmute DAC0-1 and set vol = 0 */
12337         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12338         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12339
12340         /*
12341          * Set up output mixers (0x0c - 0x0e)
12342          */
12343         /* set vol=0 to output mixers */
12344         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12345         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12346
12347         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12348         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12349
12350         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12351         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12352         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12353         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12354         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12355         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12356         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12357         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12358
12359         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12360         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12361         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12362         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12363         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12364
12365         /* set PCBEEP vol = 0, mute connections */
12366         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12367         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12368         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12369
12370         /* Unmute Selector 23h,24h and set the default input to mic-in */
12371
12372         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12374         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12375         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12376
12377         { }
12378 };
12379
12380 /*
12381  * generic initialization of ADC, input mixers and output mixers
12382  */
12383 static struct hda_verb alc268_volume_init_verbs[] = {
12384         /* set output DAC */
12385         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12386         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12387
12388         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12389         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12390         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12391         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12392         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12393
12394         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12395         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12396         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12397
12398         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12399         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12400
12401         /* set PCBEEP vol = 0, mute connections */
12402         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12403         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12404         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12405
12406         { }
12407 };
12408
12409 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12410         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12411         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12412         { } /* end */
12413 };
12414
12415 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12416         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12417         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12418         _DEFINE_CAPSRC(1),
12419         { } /* end */
12420 };
12421
12422 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12423         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12424         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12425         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12426         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12427         _DEFINE_CAPSRC(2),
12428         { } /* end */
12429 };
12430
12431 static struct hda_input_mux alc268_capture_source = {
12432         .num_items = 4,
12433         .items = {
12434                 { "Mic", 0x0 },
12435                 { "Front Mic", 0x1 },
12436                 { "Line", 0x2 },
12437                 { "CD", 0x3 },
12438         },
12439 };
12440
12441 static struct hda_input_mux alc268_acer_capture_source = {
12442         .num_items = 3,
12443         .items = {
12444                 { "Mic", 0x0 },
12445                 { "Internal Mic", 0x1 },
12446                 { "Line", 0x2 },
12447         },
12448 };
12449
12450 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12451         .num_items = 3,
12452         .items = {
12453                 { "Mic", 0x0 },
12454                 { "Internal Mic", 0x6 },
12455                 { "Line", 0x2 },
12456         },
12457 };
12458
12459 #ifdef CONFIG_SND_DEBUG
12460 static struct snd_kcontrol_new alc268_test_mixer[] = {
12461         /* Volume widgets */
12462         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12463         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12464         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12465         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12466         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12467         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12468         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12469         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12470         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12471         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12472         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12473         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12474         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12475         /* The below appears problematic on some hardwares */
12476         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12477         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12478         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12479         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12480         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12481
12482         /* Modes for retasking pin widgets */
12483         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12484         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12485         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12486         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12487
12488         /* Controls for GPIO pins, assuming they are configured as outputs */
12489         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12490         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12491         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12492         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12493
12494         /* Switches to allow the digital SPDIF output pin to be enabled.
12495          * The ALC268 does not have an SPDIF input.
12496          */
12497         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12498
12499         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12500          * this output to turn on an external amplifier.
12501          */
12502         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12503         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12504
12505         { } /* end */
12506 };
12507 #endif
12508
12509 /* create input playback/capture controls for the given pin */
12510 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12511                                     const char *ctlname, int idx)
12512 {
12513         hda_nid_t dac;
12514         int err;
12515
12516         switch (nid) {
12517         case 0x14:
12518         case 0x16:
12519                 dac = 0x02;
12520                 break;
12521         case 0x15:
12522                 dac = 0x03;
12523                 break;
12524         default:
12525                 return 0;
12526         }
12527         if (spec->multiout.dac_nids[0] != dac &&
12528             spec->multiout.dac_nids[1] != dac) {
12529                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12530                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12531                                                       HDA_OUTPUT));
12532                 if (err < 0)
12533                         return err;
12534                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12535         }
12536
12537         if (nid != 0x16)
12538                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12539                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12540         else /* mono */
12541                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12542                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12543         if (err < 0)
12544                 return err;
12545         return 0;
12546 }
12547
12548 /* add playback controls from the parsed DAC table */
12549 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12550                                              const struct auto_pin_cfg *cfg)
12551 {
12552         hda_nid_t nid;
12553         int err;
12554
12555         spec->multiout.dac_nids = spec->private_dac_nids;
12556
12557         nid = cfg->line_out_pins[0];
12558         if (nid) {
12559                 const char *name;
12560                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12561                         name = "Speaker";
12562                 else
12563                         name = "Front";
12564                 err = alc268_new_analog_output(spec, nid, name, 0);
12565                 if (err < 0)
12566                         return err;
12567         }
12568
12569         nid = cfg->speaker_pins[0];
12570         if (nid == 0x1d) {
12571                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12572                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12573                 if (err < 0)
12574                         return err;
12575         } else {
12576                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12577                 if (err < 0)
12578                         return err;
12579         }
12580         nid = cfg->hp_pins[0];
12581         if (nid) {
12582                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12583                 if (err < 0)
12584                         return err;
12585         }
12586
12587         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12588         if (nid == 0x16) {
12589                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12590                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12591                 if (err < 0)
12592                         return err;
12593         }
12594         return 0;
12595 }
12596
12597 /* create playback/capture controls for input pins */
12598 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12599                                                 const struct auto_pin_cfg *cfg)
12600 {
12601         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12602 }
12603
12604 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12605                                               hda_nid_t nid, int pin_type)
12606 {
12607         int idx;
12608
12609         alc_set_pin_output(codec, nid, pin_type);
12610         if (nid == 0x14 || nid == 0x16)
12611                 idx = 0;
12612         else
12613                 idx = 1;
12614         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12615 }
12616
12617 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12618 {
12619         struct alc_spec *spec = codec->spec;
12620         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12621         if (nid) {
12622                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12623                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12624         }
12625 }
12626
12627 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12628 {
12629         struct alc_spec *spec = codec->spec;
12630         hda_nid_t pin;
12631
12632         pin = spec->autocfg.hp_pins[0];
12633         if (pin)
12634                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12635         pin = spec->autocfg.speaker_pins[0];
12636         if (pin)
12637                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12638 }
12639
12640 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12641 {
12642         struct alc_spec *spec = codec->spec;
12643         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12644         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12645         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12646         unsigned int    dac_vol1, dac_vol2;
12647
12648         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12649                 snd_hda_codec_write(codec, speaker_nid, 0,
12650                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12651                 /* mute mixer inputs from 0x1d */
12652                 snd_hda_codec_write(codec, 0x0f, 0,
12653                                     AC_VERB_SET_AMP_GAIN_MUTE,
12654                                     AMP_IN_UNMUTE(1));
12655                 snd_hda_codec_write(codec, 0x10, 0,
12656                                     AC_VERB_SET_AMP_GAIN_MUTE,
12657                                     AMP_IN_UNMUTE(1));
12658         } else {
12659                 /* unmute mixer inputs from 0x1d */
12660                 snd_hda_codec_write(codec, 0x0f, 0,
12661                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12662                 snd_hda_codec_write(codec, 0x10, 0,
12663                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12664         }
12665
12666         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12667         if (line_nid == 0x14)
12668                 dac_vol2 = AMP_OUT_ZERO;
12669         else if (line_nid == 0x15)
12670                 dac_vol1 = AMP_OUT_ZERO;
12671         if (hp_nid == 0x14)
12672                 dac_vol2 = AMP_OUT_ZERO;
12673         else if (hp_nid == 0x15)
12674                 dac_vol1 = AMP_OUT_ZERO;
12675         if (line_nid != 0x16 || hp_nid != 0x16 ||
12676             spec->autocfg.line_out_pins[1] != 0x16 ||
12677             spec->autocfg.line_out_pins[2] != 0x16)
12678                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12679
12680         snd_hda_codec_write(codec, 0x02, 0,
12681                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12682         snd_hda_codec_write(codec, 0x03, 0,
12683                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12684 }
12685
12686 /* pcm configuration: identical with ALC880 */
12687 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12688 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12689 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12690 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12691
12692 /*
12693  * BIOS auto configuration
12694  */
12695 static int alc268_parse_auto_config(struct hda_codec *codec)
12696 {
12697         struct alc_spec *spec = codec->spec;
12698         int err;
12699         static hda_nid_t alc268_ignore[] = { 0 };
12700
12701         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12702                                            alc268_ignore);
12703         if (err < 0)
12704                 return err;
12705         if (!spec->autocfg.line_outs) {
12706                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12707                         spec->multiout.max_channels = 2;
12708                         spec->no_analog = 1;
12709                         goto dig_only;
12710                 }
12711                 return 0; /* can't find valid BIOS pin config */
12712         }
12713         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12714         if (err < 0)
12715                 return err;
12716         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12717         if (err < 0)
12718                 return err;
12719
12720         spec->multiout.max_channels = 2;
12721
12722  dig_only:
12723         /* digital only support output */
12724         if (spec->autocfg.dig_outs) {
12725                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12726                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12727         }
12728         if (spec->kctls.list)
12729                 add_mixer(spec, spec->kctls.list);
12730
12731         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12732                 add_mixer(spec, alc268_beep_mixer);
12733
12734         add_verb(spec, alc268_volume_init_verbs);
12735         spec->num_mux_defs = 2;
12736         spec->input_mux = &spec->private_imux[0];
12737
12738         err = alc_auto_add_mic_boost(codec);
12739         if (err < 0)
12740                 return err;
12741
12742         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12743
12744         return 1;
12745 }
12746
12747 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12748
12749 /* init callback for auto-configuration model -- overriding the default init */
12750 static void alc268_auto_init(struct hda_codec *codec)
12751 {
12752         struct alc_spec *spec = codec->spec;
12753         alc268_auto_init_multi_out(codec);
12754         alc268_auto_init_hp_out(codec);
12755         alc268_auto_init_mono_speaker_out(codec);
12756         alc268_auto_init_analog_input(codec);
12757         if (spec->unsol_event)
12758                 alc_inithook(codec);
12759 }
12760
12761 /*
12762  * configuration and preset
12763  */
12764 static const char *alc268_models[ALC268_MODEL_LAST] = {
12765         [ALC267_QUANTA_IL1]     = "quanta-il1",
12766         [ALC268_3ST]            = "3stack",
12767         [ALC268_TOSHIBA]        = "toshiba",
12768         [ALC268_ACER]           = "acer",
12769         [ALC268_ACER_DMIC]      = "acer-dmic",
12770         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12771         [ALC268_DELL]           = "dell",
12772         [ALC268_ZEPTO]          = "zepto",
12773 #ifdef CONFIG_SND_DEBUG
12774         [ALC268_TEST]           = "test",
12775 #endif
12776         [ALC268_AUTO]           = "auto",
12777 };
12778
12779 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12780         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12781         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12782         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12783         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12784         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12785         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12786                                                 ALC268_ACER_ASPIRE_ONE),
12787         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12788         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
12789                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
12790         /* almost compatible with toshiba but with optional digital outs;
12791          * auto-probing seems working fine
12792          */
12793         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12794                            ALC268_AUTO),
12795         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12796         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12797         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12798         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12799         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12800         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12801         {}
12802 };
12803
12804 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12805 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12806         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12807         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12808         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12809                            ALC268_TOSHIBA),
12810         {}
12811 };
12812
12813 static struct alc_config_preset alc268_presets[] = {
12814         [ALC267_QUANTA_IL1] = {
12815                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12816                             alc268_capture_nosrc_mixer },
12817                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12818                                 alc267_quanta_il1_verbs },
12819                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12820                 .dac_nids = alc268_dac_nids,
12821                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12822                 .adc_nids = alc268_adc_nids_alt,
12823                 .hp_nid = 0x03,
12824                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12825                 .channel_mode = alc268_modes,
12826                 .unsol_event = alc_sku_unsol_event,
12827                 .setup = alc267_quanta_il1_setup,
12828                 .init_hook = alc_inithook,
12829         },
12830         [ALC268_3ST] = {
12831                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12832                             alc268_beep_mixer },
12833                 .init_verbs = { alc268_base_init_verbs },
12834                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12835                 .dac_nids = alc268_dac_nids,
12836                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12837                 .adc_nids = alc268_adc_nids_alt,
12838                 .capsrc_nids = alc268_capsrc_nids,
12839                 .hp_nid = 0x03,
12840                 .dig_out_nid = ALC268_DIGOUT_NID,
12841                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12842                 .channel_mode = alc268_modes,
12843                 .input_mux = &alc268_capture_source,
12844         },
12845         [ALC268_TOSHIBA] = {
12846                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12847                             alc268_beep_mixer },
12848                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12849                                 alc268_toshiba_verbs },
12850                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12851                 .dac_nids = alc268_dac_nids,
12852                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12853                 .adc_nids = alc268_adc_nids_alt,
12854                 .capsrc_nids = alc268_capsrc_nids,
12855                 .hp_nid = 0x03,
12856                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12857                 .channel_mode = alc268_modes,
12858                 .input_mux = &alc268_capture_source,
12859                 .unsol_event = alc268_toshiba_unsol_event,
12860                 .setup = alc268_toshiba_setup,
12861                 .init_hook = alc268_toshiba_automute,
12862         },
12863         [ALC268_ACER] = {
12864                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12865                             alc268_beep_mixer },
12866                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12867                                 alc268_acer_verbs },
12868                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12869                 .dac_nids = alc268_dac_nids,
12870                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12871                 .adc_nids = alc268_adc_nids_alt,
12872                 .capsrc_nids = alc268_capsrc_nids,
12873                 .hp_nid = 0x02,
12874                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12875                 .channel_mode = alc268_modes,
12876                 .input_mux = &alc268_acer_capture_source,
12877                 .unsol_event = alc268_acer_unsol_event,
12878                 .init_hook = alc268_acer_init_hook,
12879         },
12880         [ALC268_ACER_DMIC] = {
12881                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12882                             alc268_beep_mixer },
12883                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12884                                 alc268_acer_verbs },
12885                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12886                 .dac_nids = alc268_dac_nids,
12887                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12888                 .adc_nids = alc268_adc_nids_alt,
12889                 .capsrc_nids = alc268_capsrc_nids,
12890                 .hp_nid = 0x02,
12891                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12892                 .channel_mode = alc268_modes,
12893                 .input_mux = &alc268_acer_dmic_capture_source,
12894                 .unsol_event = alc268_acer_unsol_event,
12895                 .init_hook = alc268_acer_init_hook,
12896         },
12897         [ALC268_ACER_ASPIRE_ONE] = {
12898                 .mixers = { alc268_acer_aspire_one_mixer,
12899                             alc268_beep_mixer,
12900                             alc268_capture_nosrc_mixer },
12901                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12902                                 alc268_acer_aspire_one_verbs },
12903                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12904                 .dac_nids = alc268_dac_nids,
12905                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12906                 .adc_nids = alc268_adc_nids_alt,
12907                 .capsrc_nids = alc268_capsrc_nids,
12908                 .hp_nid = 0x03,
12909                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12910                 .channel_mode = alc268_modes,
12911                 .unsol_event = alc268_acer_lc_unsol_event,
12912                 .setup = alc268_acer_lc_setup,
12913                 .init_hook = alc268_acer_lc_init_hook,
12914         },
12915         [ALC268_DELL] = {
12916                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
12917                             alc268_capture_nosrc_mixer },
12918                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12919                                 alc268_dell_verbs },
12920                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12921                 .dac_nids = alc268_dac_nids,
12922                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12923                 .adc_nids = alc268_adc_nids_alt,
12924                 .capsrc_nids = alc268_capsrc_nids,
12925                 .hp_nid = 0x02,
12926                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12927                 .channel_mode = alc268_modes,
12928                 .unsol_event = alc_sku_unsol_event,
12929                 .setup = alc268_dell_setup,
12930                 .init_hook = alc_inithook,
12931         },
12932         [ALC268_ZEPTO] = {
12933                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12934                             alc268_beep_mixer },
12935                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12936                                 alc268_toshiba_verbs },
12937                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12938                 .dac_nids = alc268_dac_nids,
12939                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12940                 .adc_nids = alc268_adc_nids_alt,
12941                 .capsrc_nids = alc268_capsrc_nids,
12942                 .hp_nid = 0x03,
12943                 .dig_out_nid = ALC268_DIGOUT_NID,
12944                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12945                 .channel_mode = alc268_modes,
12946                 .input_mux = &alc268_capture_source,
12947                 .setup = alc268_toshiba_setup,
12948                 .init_hook = alc268_toshiba_automute,
12949         },
12950 #ifdef CONFIG_SND_DEBUG
12951         [ALC268_TEST] = {
12952                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12953                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12954                                 alc268_volume_init_verbs },
12955                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12956                 .dac_nids = alc268_dac_nids,
12957                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12958                 .adc_nids = alc268_adc_nids_alt,
12959                 .capsrc_nids = alc268_capsrc_nids,
12960                 .hp_nid = 0x03,
12961                 .dig_out_nid = ALC268_DIGOUT_NID,
12962                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12963                 .channel_mode = alc268_modes,
12964                 .input_mux = &alc268_capture_source,
12965         },
12966 #endif
12967 };
12968
12969 static int patch_alc268(struct hda_codec *codec)
12970 {
12971         struct alc_spec *spec;
12972         int board_config;
12973         int i, has_beep, err;
12974
12975         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12976         if (spec == NULL)
12977                 return -ENOMEM;
12978
12979         codec->spec = spec;
12980
12981         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12982                                                   alc268_models,
12983                                                   alc268_cfg_tbl);
12984
12985         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
12986                 board_config = snd_hda_check_board_codec_sid_config(codec,
12987                         ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
12988
12989         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12990                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12991                        codec->chip_name);
12992                 board_config = ALC268_AUTO;
12993         }
12994
12995         if (board_config == ALC268_AUTO) {
12996                 /* automatic parse from the BIOS config */
12997                 err = alc268_parse_auto_config(codec);
12998                 if (err < 0) {
12999                         alc_free(codec);
13000                         return err;
13001                 } else if (!err) {
13002                         printk(KERN_INFO
13003                                "hda_codec: Cannot set up configuration "
13004                                "from BIOS.  Using base mode...\n");
13005                         board_config = ALC268_3ST;
13006                 }
13007         }
13008
13009         if (board_config != ALC268_AUTO)
13010                 setup_preset(codec, &alc268_presets[board_config]);
13011
13012         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13013         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13014         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13015
13016         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13017
13018         has_beep = 0;
13019         for (i = 0; i < spec->num_mixers; i++) {
13020                 if (spec->mixers[i] == alc268_beep_mixer) {
13021                         has_beep = 1;
13022                         break;
13023                 }
13024         }
13025
13026         if (has_beep) {
13027                 err = snd_hda_attach_beep_device(codec, 0x1);
13028                 if (err < 0) {
13029                         alc_free(codec);
13030                         return err;
13031                 }
13032                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13033                         /* override the amp caps for beep generator */
13034                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13035                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13036                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13037                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13038                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13039         }
13040
13041         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13042                 /* check whether NID 0x07 is valid */
13043                 unsigned int wcap = get_wcaps(codec, 0x07);
13044                 int i;
13045
13046                 spec->capsrc_nids = alc268_capsrc_nids;
13047                 /* get type */
13048                 wcap = get_wcaps_type(wcap);
13049                 if (spec->auto_mic ||
13050                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13051                         spec->adc_nids = alc268_adc_nids_alt;
13052                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13053                         if (spec->auto_mic)
13054                                 fixup_automic_adc(codec);
13055                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13056                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13057                         else
13058                                 add_mixer(spec, alc268_capture_alt_mixer);
13059                 } else {
13060                         spec->adc_nids = alc268_adc_nids;
13061                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13062                         add_mixer(spec, alc268_capture_mixer);
13063                 }
13064                 /* set default input source */
13065                 for (i = 0; i < spec->num_adc_nids; i++)
13066                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13067                                 0, AC_VERB_SET_CONNECT_SEL,
13068                                 i < spec->num_mux_defs ?
13069                                 spec->input_mux[i].items[0].index :
13070                                 spec->input_mux->items[0].index);
13071         }
13072
13073         spec->vmaster_nid = 0x02;
13074
13075         codec->patch_ops = alc_patch_ops;
13076         if (board_config == ALC268_AUTO)
13077                 spec->init_hook = alc268_auto_init;
13078
13079         codec->proc_widget_hook = print_realtek_coef;
13080
13081         return 0;
13082 }
13083
13084 /*
13085  *  ALC269 channel source setting (2 channel)
13086  */
13087 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13088
13089 #define alc269_dac_nids         alc260_dac_nids
13090
13091 static hda_nid_t alc269_adc_nids[1] = {
13092         /* ADC1 */
13093         0x08,
13094 };
13095
13096 static hda_nid_t alc269_capsrc_nids[1] = {
13097         0x23,
13098 };
13099
13100 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
13101  *       not a mux!
13102  */
13103
13104 #define alc269_modes            alc260_modes
13105 #define alc269_capture_source   alc880_lg_lw_capture_source
13106
13107 static struct snd_kcontrol_new alc269_base_mixer[] = {
13108         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13109         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13110         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13111         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13112         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13113         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13114         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13115         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13116         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13117         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13118         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13119         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13120         { } /* end */
13121 };
13122
13123 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13124         /* output mixer control */
13125         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13126         {
13127                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13128                 .name = "Master Playback Switch",
13129                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
13130                 .info = snd_hda_mixer_amp_switch_info,
13131                 .get = snd_hda_mixer_amp_switch_get,
13132                 .put = alc268_acer_master_sw_put,
13133                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13134         },
13135         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13136         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13137         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13138         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13139         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13140         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13141         { }
13142 };
13143
13144 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13145         /* output mixer control */
13146         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13147         {
13148                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13149                 .name = "Master Playback Switch",
13150                 .subdevice = HDA_SUBDEV_NID_FLAG | HDA_SUBDEV_AMP_FLAG | 0x14,
13151                 .info = snd_hda_mixer_amp_switch_info,
13152                 .get = snd_hda_mixer_amp_switch_get,
13153                 .put = alc268_acer_master_sw_put,
13154                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13155         },
13156         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13157         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13158         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13159         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13160         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13161         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13162         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13163         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13164         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13165         { }
13166 };
13167
13168 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
13169         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13170         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13171         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13172         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13173         { } /* end */
13174 };
13175
13176 /* capture mixer elements */
13177 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
13178         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13179         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13180         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13181         { } /* end */
13182 };
13183
13184 /* FSC amilo */
13185 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
13186
13187 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13188         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13189         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13190         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13191         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13192         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13193         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13194         { }
13195 };
13196
13197 static struct hda_verb alc269_lifebook_verbs[] = {
13198         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13199         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13200         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13201         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13202         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13203         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13204         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13205         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13206         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13207         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13208         { }
13209 };
13210
13211 /* toggle speaker-output according to the hp-jack state */
13212 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13213 {
13214         unsigned int present;
13215         unsigned char bits;
13216
13217         present = snd_hda_jack_detect(codec, 0x15);
13218         bits = present ? AMP_IN_MUTE(0) : 0;
13219         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13220                         AMP_IN_MUTE(0), bits);
13221         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13222                         AMP_IN_MUTE(0), bits);
13223
13224         snd_hda_codec_write(codec, 0x20, 0,
13225                         AC_VERB_SET_COEF_INDEX, 0x0c);
13226         snd_hda_codec_write(codec, 0x20, 0,
13227                         AC_VERB_SET_PROC_COEF, 0x680);
13228
13229         snd_hda_codec_write(codec, 0x20, 0,
13230                         AC_VERB_SET_COEF_INDEX, 0x0c);
13231         snd_hda_codec_write(codec, 0x20, 0,
13232                         AC_VERB_SET_PROC_COEF, 0x480);
13233 }
13234
13235 /* toggle speaker-output according to the hp-jacks state */
13236 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13237 {
13238         unsigned int present;
13239         unsigned char bits;
13240
13241         /* Check laptop headphone socket */
13242         present = snd_hda_jack_detect(codec, 0x15);
13243
13244         /* Check port replicator headphone socket */
13245         present |= snd_hda_jack_detect(codec, 0x1a);
13246
13247         bits = present ? AMP_IN_MUTE(0) : 0;
13248         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13249                         AMP_IN_MUTE(0), bits);
13250         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13251                         AMP_IN_MUTE(0), bits);
13252
13253         snd_hda_codec_write(codec, 0x20, 0,
13254                         AC_VERB_SET_COEF_INDEX, 0x0c);
13255         snd_hda_codec_write(codec, 0x20, 0,
13256                         AC_VERB_SET_PROC_COEF, 0x680);
13257
13258         snd_hda_codec_write(codec, 0x20, 0,
13259                         AC_VERB_SET_COEF_INDEX, 0x0c);
13260         snd_hda_codec_write(codec, 0x20, 0,
13261                         AC_VERB_SET_PROC_COEF, 0x480);
13262 }
13263
13264 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13265 {
13266         unsigned int present_laptop;
13267         unsigned int present_dock;
13268
13269         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13270         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13271
13272         /* Laptop mic port overrides dock mic port, design decision */
13273         if (present_dock)
13274                 snd_hda_codec_write(codec, 0x23, 0,
13275                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13276         if (present_laptop)
13277                 snd_hda_codec_write(codec, 0x23, 0,
13278                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13279         if (!present_dock && !present_laptop)
13280                 snd_hda_codec_write(codec, 0x23, 0,
13281                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13282 }
13283
13284 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13285                                     unsigned int res)
13286 {
13287         switch (res >> 26) {
13288         case ALC880_HP_EVENT:
13289                 alc269_quanta_fl1_speaker_automute(codec);
13290                 break;
13291         case ALC880_MIC_EVENT:
13292                 alc_mic_automute(codec);
13293                 break;
13294         }
13295 }
13296
13297 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13298                                         unsigned int res)
13299 {
13300         if ((res >> 26) == ALC880_HP_EVENT)
13301                 alc269_lifebook_speaker_automute(codec);
13302         if ((res >> 26) == ALC880_MIC_EVENT)
13303                 alc269_lifebook_mic_autoswitch(codec);
13304 }
13305
13306 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13307 {
13308         struct alc_spec *spec = codec->spec;
13309         spec->ext_mic.pin = 0x18;
13310         spec->ext_mic.mux_idx = 0;
13311         spec->int_mic.pin = 0x19;
13312         spec->int_mic.mux_idx = 1;
13313         spec->auto_mic = 1;
13314 }
13315
13316 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13317 {
13318         alc269_quanta_fl1_speaker_automute(codec);
13319         alc_mic_automute(codec);
13320 }
13321
13322 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13323 {
13324         alc269_lifebook_speaker_automute(codec);
13325         alc269_lifebook_mic_autoswitch(codec);
13326 }
13327
13328 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13329         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13330         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13331         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13332         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13333         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13334         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13335         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13336         {}
13337 };
13338
13339 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13340         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13341         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13342         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13343         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13344         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13345         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13346         {}
13347 };
13348
13349 /* toggle speaker-output according to the hp-jack state */
13350 static void alc269_speaker_automute(struct hda_codec *codec)
13351 {
13352         unsigned int present;
13353         unsigned char bits;
13354
13355         present = snd_hda_jack_detect(codec, 0x15);
13356         bits = present ? AMP_IN_MUTE(0) : 0;
13357         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13358                                 AMP_IN_MUTE(0), bits);
13359         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13360                                 AMP_IN_MUTE(0), bits);
13361 }
13362
13363 /* unsolicited event for HP jack sensing */
13364 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13365                                      unsigned int res)
13366 {
13367         switch (res >> 26) {
13368         case ALC880_HP_EVENT:
13369                 alc269_speaker_automute(codec);
13370                 break;
13371         case ALC880_MIC_EVENT:
13372                 alc_mic_automute(codec);
13373                 break;
13374         }
13375 }
13376
13377 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13378 {
13379         struct alc_spec *spec = codec->spec;
13380         spec->ext_mic.pin = 0x18;
13381         spec->ext_mic.mux_idx = 0;
13382         spec->int_mic.pin = 0x12;
13383         spec->int_mic.mux_idx = 5;
13384         spec->auto_mic = 1;
13385 }
13386
13387 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13388 {
13389         struct alc_spec *spec = codec->spec;
13390         spec->ext_mic.pin = 0x18;
13391         spec->ext_mic.mux_idx = 0;
13392         spec->int_mic.pin = 0x19;
13393         spec->int_mic.mux_idx = 1;
13394         spec->auto_mic = 1;
13395 }
13396
13397 static void alc269_eeepc_inithook(struct hda_codec *codec)
13398 {
13399         alc269_speaker_automute(codec);
13400         alc_mic_automute(codec);
13401 }
13402
13403 /*
13404  * generic initialization of ADC, input mixers and output mixers
13405  */
13406 static struct hda_verb alc269_init_verbs[] = {
13407         /*
13408          * Unmute ADC0 and set the default input to mic-in
13409          */
13410         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13411
13412         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13413          * analog-loopback mixer widget
13414          * Note: PASD motherboards uses the Line In 2 as the input for
13415          * front panel mic (mic 2)
13416          */
13417         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13418         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13419         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13420         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13421         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13422         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13423
13424         /*
13425          * Set up output mixers (0x0c - 0x0e)
13426          */
13427         /* set vol=0 to output mixers */
13428         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13429         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13430
13431         /* set up input amps for analog loopback */
13432         /* Amp Indices: DAC = 0, mixer = 1 */
13433         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13434         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13435         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13436         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13437         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13438         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13439
13440         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13441         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13442         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13443         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13444         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13445         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13446         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13447
13448         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13449         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13450         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13451         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13452         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13453         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13454         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13455
13456         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13457         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13458
13459         /* FIXME: use matrix-type input source selection */
13460         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13461         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13462         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13463         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13464         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13465         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13466
13467         /* set EAPD */
13468         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13469         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13470         { }
13471 };
13472
13473 #define alc269_auto_create_multi_out_ctls \
13474         alc268_auto_create_multi_out_ctls
13475 #define alc269_auto_create_input_ctls \
13476         alc268_auto_create_input_ctls
13477
13478 #ifdef CONFIG_SND_HDA_POWER_SAVE
13479 #define alc269_loopbacks        alc880_loopbacks
13480 #endif
13481
13482 /* pcm configuration: identical with ALC880 */
13483 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13484 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13485 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13486 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13487
13488 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13489         .substreams = 1,
13490         .channels_min = 2,
13491         .channels_max = 8,
13492         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13493         /* NID is set in alc_build_pcms */
13494         .ops = {
13495                 .open = alc880_playback_pcm_open,
13496                 .prepare = alc880_playback_pcm_prepare,
13497                 .cleanup = alc880_playback_pcm_cleanup
13498         },
13499 };
13500
13501 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13502         .substreams = 1,
13503         .channels_min = 2,
13504         .channels_max = 2,
13505         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13506         /* NID is set in alc_build_pcms */
13507 };
13508
13509 /*
13510  * BIOS auto configuration
13511  */
13512 static int alc269_parse_auto_config(struct hda_codec *codec)
13513 {
13514         struct alc_spec *spec = codec->spec;
13515         int err;
13516         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13517
13518         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13519                                            alc269_ignore);
13520         if (err < 0)
13521                 return err;
13522
13523         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13524         if (err < 0)
13525                 return err;
13526         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13527         if (err < 0)
13528                 return err;
13529
13530         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13531
13532         if (spec->autocfg.dig_outs)
13533                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13534
13535         if (spec->kctls.list)
13536                 add_mixer(spec, spec->kctls.list);
13537
13538         add_verb(spec, alc269_init_verbs);
13539         spec->num_mux_defs = 1;
13540         spec->input_mux = &spec->private_imux[0];
13541         /* set default input source */
13542         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13543                                   0, AC_VERB_SET_CONNECT_SEL,
13544                                   spec->input_mux->items[0].index);
13545
13546         err = alc_auto_add_mic_boost(codec);
13547         if (err < 0)
13548                 return err;
13549
13550         if (!spec->cap_mixer && !spec->no_analog)
13551                 set_capture_mixer(codec);
13552
13553         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13554
13555         return 1;
13556 }
13557
13558 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13559 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13560 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13561
13562
13563 /* init callback for auto-configuration model -- overriding the default init */
13564 static void alc269_auto_init(struct hda_codec *codec)
13565 {
13566         struct alc_spec *spec = codec->spec;
13567         alc269_auto_init_multi_out(codec);
13568         alc269_auto_init_hp_out(codec);
13569         alc269_auto_init_analog_input(codec);
13570         if (spec->unsol_event)
13571                 alc_inithook(codec);
13572 }
13573
13574 /*
13575  * configuration and preset
13576  */
13577 static const char *alc269_models[ALC269_MODEL_LAST] = {
13578         [ALC269_BASIC]                  = "basic",
13579         [ALC269_QUANTA_FL1]             = "quanta",
13580         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
13581         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
13582         [ALC269_FUJITSU]                = "fujitsu",
13583         [ALC269_LIFEBOOK]               = "lifebook",
13584         [ALC269_AUTO]                   = "auto",
13585 };
13586
13587 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13588         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13589         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13590                       ALC269_ASUS_EEEPC_P703),
13591         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13592         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13593         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13594         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13595         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13596         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13597         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13598                       ALC269_ASUS_EEEPC_P901),
13599         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13600                       ALC269_ASUS_EEEPC_P901),
13601         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13602         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13603         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13604         {}
13605 };
13606
13607 static struct alc_config_preset alc269_presets[] = {
13608         [ALC269_BASIC] = {
13609                 .mixers = { alc269_base_mixer },
13610                 .init_verbs = { alc269_init_verbs },
13611                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13612                 .dac_nids = alc269_dac_nids,
13613                 .hp_nid = 0x03,
13614                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13615                 .channel_mode = alc269_modes,
13616                 .input_mux = &alc269_capture_source,
13617         },
13618         [ALC269_QUANTA_FL1] = {
13619                 .mixers = { alc269_quanta_fl1_mixer },
13620                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13621                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13622                 .dac_nids = alc269_dac_nids,
13623                 .hp_nid = 0x03,
13624                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13625                 .channel_mode = alc269_modes,
13626                 .input_mux = &alc269_capture_source,
13627                 .unsol_event = alc269_quanta_fl1_unsol_event,
13628                 .setup = alc269_quanta_fl1_setup,
13629                 .init_hook = alc269_quanta_fl1_init_hook,
13630         },
13631         [ALC269_ASUS_EEEPC_P703] = {
13632                 .mixers = { alc269_eeepc_mixer },
13633                 .cap_mixer = alc269_epc_capture_mixer,
13634                 .init_verbs = { alc269_init_verbs,
13635                                 alc269_eeepc_amic_init_verbs },
13636                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13637                 .dac_nids = alc269_dac_nids,
13638                 .hp_nid = 0x03,
13639                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13640                 .channel_mode = alc269_modes,
13641                 .unsol_event = alc269_eeepc_unsol_event,
13642                 .setup = alc269_eeepc_amic_setup,
13643                 .init_hook = alc269_eeepc_inithook,
13644         },
13645         [ALC269_ASUS_EEEPC_P901] = {
13646                 .mixers = { alc269_eeepc_mixer },
13647                 .cap_mixer = alc269_epc_capture_mixer,
13648                 .init_verbs = { alc269_init_verbs,
13649                                 alc269_eeepc_dmic_init_verbs },
13650                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13651                 .dac_nids = alc269_dac_nids,
13652                 .hp_nid = 0x03,
13653                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13654                 .channel_mode = alc269_modes,
13655                 .unsol_event = alc269_eeepc_unsol_event,
13656                 .setup = alc269_eeepc_dmic_setup,
13657                 .init_hook = alc269_eeepc_inithook,
13658         },
13659         [ALC269_FUJITSU] = {
13660                 .mixers = { alc269_fujitsu_mixer },
13661                 .cap_mixer = alc269_epc_capture_mixer,
13662                 .init_verbs = { alc269_init_verbs,
13663                                 alc269_eeepc_dmic_init_verbs },
13664                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13665                 .dac_nids = alc269_dac_nids,
13666                 .hp_nid = 0x03,
13667                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13668                 .channel_mode = alc269_modes,
13669                 .unsol_event = alc269_eeepc_unsol_event,
13670                 .setup = alc269_eeepc_dmic_setup,
13671                 .init_hook = alc269_eeepc_inithook,
13672         },
13673         [ALC269_LIFEBOOK] = {
13674                 .mixers = { alc269_lifebook_mixer },
13675                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13676                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13677                 .dac_nids = alc269_dac_nids,
13678                 .hp_nid = 0x03,
13679                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13680                 .channel_mode = alc269_modes,
13681                 .input_mux = &alc269_capture_source,
13682                 .unsol_event = alc269_lifebook_unsol_event,
13683                 .init_hook = alc269_lifebook_init_hook,
13684         },
13685 };
13686
13687 static int patch_alc269(struct hda_codec *codec)
13688 {
13689         struct alc_spec *spec;
13690         int board_config;
13691         int err;
13692
13693         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13694         if (spec == NULL)
13695                 return -ENOMEM;
13696
13697         codec->spec = spec;
13698
13699         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13700
13701         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
13702                 kfree(codec->chip_name);
13703                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
13704                 if (!codec->chip_name) {
13705                         alc_free(codec);
13706                         return -ENOMEM;
13707                 }
13708         }
13709
13710         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13711                                                   alc269_models,
13712                                                   alc269_cfg_tbl);
13713
13714         if (board_config < 0) {
13715                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13716                        codec->chip_name);
13717                 board_config = ALC269_AUTO;
13718         }
13719
13720         if (board_config == ALC269_AUTO) {
13721                 /* automatic parse from the BIOS config */
13722                 err = alc269_parse_auto_config(codec);
13723                 if (err < 0) {
13724                         alc_free(codec);
13725                         return err;
13726                 } else if (!err) {
13727                         printk(KERN_INFO
13728                                "hda_codec: Cannot set up configuration "
13729                                "from BIOS.  Using base mode...\n");
13730                         board_config = ALC269_BASIC;
13731                 }
13732         }
13733
13734         err = snd_hda_attach_beep_device(codec, 0x1);
13735         if (err < 0) {
13736                 alc_free(codec);
13737                 return err;
13738         }
13739
13740         if (board_config != ALC269_AUTO)
13741                 setup_preset(codec, &alc269_presets[board_config]);
13742
13743         if (codec->subsystem_id == 0x17aa3bf8) {
13744                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13745                  * fix the sample rate of analog I/O to 44.1kHz
13746                  */
13747                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13748                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13749         } else {
13750                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13751                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13752         }
13753         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13754         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13755
13756         spec->adc_nids = alc269_adc_nids;
13757         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13758         spec->capsrc_nids = alc269_capsrc_nids;
13759         if (!spec->cap_mixer)
13760                 set_capture_mixer(codec);
13761         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13762
13763         spec->vmaster_nid = 0x02;
13764
13765         codec->patch_ops = alc_patch_ops;
13766         if (board_config == ALC269_AUTO)
13767                 spec->init_hook = alc269_auto_init;
13768 #ifdef CONFIG_SND_HDA_POWER_SAVE
13769         if (!spec->loopback.amplist)
13770                 spec->loopback.amplist = alc269_loopbacks;
13771 #endif
13772         codec->proc_widget_hook = print_realtek_coef;
13773
13774         return 0;
13775 }
13776
13777 /*
13778  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13779  */
13780
13781 /*
13782  * set the path ways for 2 channel output
13783  * need to set the codec line out and mic 1 pin widgets to inputs
13784  */
13785 static struct hda_verb alc861_threestack_ch2_init[] = {
13786         /* set pin widget 1Ah (line in) for input */
13787         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13788         /* set pin widget 18h (mic1/2) for input, for mic also enable
13789          * the vref
13790          */
13791         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13792
13793         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13794 #if 0
13795         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13796         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13797 #endif
13798         { } /* end */
13799 };
13800 /*
13801  * 6ch mode
13802  * need to set the codec line out and mic 1 pin widgets to outputs
13803  */
13804 static struct hda_verb alc861_threestack_ch6_init[] = {
13805         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13806         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13807         /* set pin widget 18h (mic1) for output (CLFE)*/
13808         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13809
13810         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13811         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13812
13813         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13814 #if 0
13815         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13816         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13817 #endif
13818         { } /* end */
13819 };
13820
13821 static struct hda_channel_mode alc861_threestack_modes[2] = {
13822         { 2, alc861_threestack_ch2_init },
13823         { 6, alc861_threestack_ch6_init },
13824 };
13825 /* Set mic1 as input and unmute the mixer */
13826 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13827         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13828         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13829         { } /* end */
13830 };
13831 /* Set mic1 as output and mute mixer */
13832 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13833         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13834         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13835         { } /* end */
13836 };
13837
13838 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13839         { 2, alc861_uniwill_m31_ch2_init },
13840         { 4, alc861_uniwill_m31_ch4_init },
13841 };
13842
13843 /* Set mic1 and line-in as input and unmute the mixer */
13844 static struct hda_verb alc861_asus_ch2_init[] = {
13845         /* set pin widget 1Ah (line in) for input */
13846         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13847         /* set pin widget 18h (mic1/2) for input, for mic also enable
13848          * the vref
13849          */
13850         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13851
13852         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13853 #if 0
13854         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13855         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13856 #endif
13857         { } /* end */
13858 };
13859 /* Set mic1 nad line-in as output and mute mixer */
13860 static struct hda_verb alc861_asus_ch6_init[] = {
13861         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13862         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13863         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13864         /* set pin widget 18h (mic1) for output (CLFE)*/
13865         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13866         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13867         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13868         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13869
13870         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13871 #if 0
13872         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13873         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13874 #endif
13875         { } /* end */
13876 };
13877
13878 static struct hda_channel_mode alc861_asus_modes[2] = {
13879         { 2, alc861_asus_ch2_init },
13880         { 6, alc861_asus_ch6_init },
13881 };
13882
13883 /* patch-ALC861 */
13884
13885 static struct snd_kcontrol_new alc861_base_mixer[] = {
13886         /* output mixer control */
13887         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13888         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13889         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13890         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13891         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13892
13893         /*Input mixer control */
13894         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13895            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13896         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13897         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13898         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13899         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13900         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13901         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13902         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13903         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13904
13905         { } /* end */
13906 };
13907
13908 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13909         /* output mixer control */
13910         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13911         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13912         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13913         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13914         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13915
13916         /* Input mixer control */
13917         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13918            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13919         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13920         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13921         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13922         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13923         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13924         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13925         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13926         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13927
13928         {
13929                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13930                 .name = "Channel Mode",
13931                 .info = alc_ch_mode_info,
13932                 .get = alc_ch_mode_get,
13933                 .put = alc_ch_mode_put,
13934                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13935         },
13936         { } /* end */
13937 };
13938
13939 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13940         /* output mixer control */
13941         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13942         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13943         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13944
13945         { } /* end */
13946 };
13947
13948 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13949         /* output mixer control */
13950         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13951         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13952         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13953         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13954         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13955
13956         /* Input mixer control */
13957         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13958            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13959         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13960         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13961         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13962         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13963         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13964         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13965         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13966         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13967
13968         {
13969                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13970                 .name = "Channel Mode",
13971                 .info = alc_ch_mode_info,
13972                 .get = alc_ch_mode_get,
13973                 .put = alc_ch_mode_put,
13974                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13975         },
13976         { } /* end */
13977 };
13978
13979 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13980         /* output mixer control */
13981         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13982         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13983         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13984         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13985         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13986
13987         /* Input mixer control */
13988         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13989         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13990         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13991         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13992         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13993         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13994         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13995         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13996         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13997         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13998
13999         {
14000                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14001                 .name = "Channel Mode",
14002                 .info = alc_ch_mode_info,
14003                 .get = alc_ch_mode_get,
14004                 .put = alc_ch_mode_put,
14005                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14006         },
14007         { }
14008 };
14009
14010 /* additional mixer */
14011 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14012         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14013         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14014         { }
14015 };
14016
14017 /*
14018  * generic initialization of ADC, input mixers and output mixers
14019  */
14020 static struct hda_verb alc861_base_init_verbs[] = {
14021         /*
14022          * Unmute ADC0 and set the default input to mic-in
14023          */
14024         /* port-A for surround (rear panel) */
14025         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14026         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14027         /* port-B for mic-in (rear panel) with vref */
14028         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14029         /* port-C for line-in (rear panel) */
14030         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14031         /* port-D for Front */
14032         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14033         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14034         /* port-E for HP out (front panel) */
14035         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14036         /* route front PCM to HP */
14037         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14038         /* port-F for mic-in (front panel) with vref */
14039         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14040         /* port-G for CLFE (rear panel) */
14041         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14042         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14043         /* port-H for side (rear panel) */
14044         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14045         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14046         /* CD-in */
14047         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14048         /* route front mic to ADC1*/
14049         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14050         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14051
14052         /* Unmute DAC0~3 & spdif out*/
14053         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14054         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14055         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14056         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14057         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14058
14059         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14060         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14061         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14062         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14063         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14064
14065         /* Unmute Stereo Mixer 15 */
14066         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14067         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14068         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14069         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14070
14071         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14072         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14073         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14074         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14075         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14076         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14077         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14078         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14079         /* hp used DAC 3 (Front) */
14080         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14081         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14082
14083         { }
14084 };
14085
14086 static struct hda_verb alc861_threestack_init_verbs[] = {
14087         /*
14088          * Unmute ADC0 and set the default input to mic-in
14089          */
14090         /* port-A for surround (rear panel) */
14091         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14092         /* port-B for mic-in (rear panel) with vref */
14093         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14094         /* port-C for line-in (rear panel) */
14095         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14096         /* port-D for Front */
14097         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14098         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14099         /* port-E for HP out (front panel) */
14100         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14101         /* route front PCM to HP */
14102         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14103         /* port-F for mic-in (front panel) with vref */
14104         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14105         /* port-G for CLFE (rear panel) */
14106         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14107         /* port-H for side (rear panel) */
14108         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14109         /* CD-in */
14110         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14111         /* route front mic to ADC1*/
14112         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14113         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14114         /* Unmute DAC0~3 & spdif out*/
14115         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14116         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14117         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14118         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14119         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14120
14121         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14122         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14123         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14124         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14125         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14126
14127         /* Unmute Stereo Mixer 15 */
14128         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14129         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14130         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14131         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14132
14133         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14134         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14135         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14136         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14137         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14138         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14139         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14140         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14141         /* hp used DAC 3 (Front) */
14142         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14143         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14144         { }
14145 };
14146
14147 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14148         /*
14149          * Unmute ADC0 and set the default input to mic-in
14150          */
14151         /* port-A for surround (rear panel) */
14152         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14153         /* port-B for mic-in (rear panel) with vref */
14154         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14155         /* port-C for line-in (rear panel) */
14156         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14157         /* port-D for Front */
14158         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14159         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14160         /* port-E for HP out (front panel) */
14161         /* this has to be set to VREF80 */
14162         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14163         /* route front PCM to HP */
14164         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14165         /* port-F for mic-in (front panel) with vref */
14166         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14167         /* port-G for CLFE (rear panel) */
14168         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14169         /* port-H for side (rear panel) */
14170         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14171         /* CD-in */
14172         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14173         /* route front mic to ADC1*/
14174         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14175         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14176         /* Unmute DAC0~3 & spdif out*/
14177         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14178         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14179         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14180         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14181         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14182
14183         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14184         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14185         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14186         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14187         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14188
14189         /* Unmute Stereo Mixer 15 */
14190         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14191         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14192         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14193         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14194
14195         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14196         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14197         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14198         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14199         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14200         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14201         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14202         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14203         /* hp used DAC 3 (Front) */
14204         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14205         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14206         { }
14207 };
14208
14209 static struct hda_verb alc861_asus_init_verbs[] = {
14210         /*
14211          * Unmute ADC0 and set the default input to mic-in
14212          */
14213         /* port-A for surround (rear panel)
14214          * according to codec#0 this is the HP jack
14215          */
14216         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14217         /* route front PCM to HP */
14218         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14219         /* port-B for mic-in (rear panel) with vref */
14220         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14221         /* port-C for line-in (rear panel) */
14222         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14223         /* port-D for Front */
14224         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14225         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14226         /* port-E for HP out (front panel) */
14227         /* this has to be set to VREF80 */
14228         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14229         /* route front PCM to HP */
14230         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14231         /* port-F for mic-in (front panel) with vref */
14232         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14233         /* port-G for CLFE (rear panel) */
14234         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14235         /* port-H for side (rear panel) */
14236         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14237         /* CD-in */
14238         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14239         /* route front mic to ADC1*/
14240         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14241         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14242         /* Unmute DAC0~3 & spdif out*/
14243         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14244         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14245         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14246         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14248         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14249         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14250         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14251         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14252         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14253
14254         /* Unmute Stereo Mixer 15 */
14255         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14256         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14257         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14258         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14259
14260         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14261         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14262         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14263         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14264         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14265         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14266         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14267         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14268         /* hp used DAC 3 (Front) */
14269         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14270         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14271         { }
14272 };
14273
14274 /* additional init verbs for ASUS laptops */
14275 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14276         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14277         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14278         { }
14279 };
14280
14281 /*
14282  * generic initialization of ADC, input mixers and output mixers
14283  */
14284 static struct hda_verb alc861_auto_init_verbs[] = {
14285         /*
14286          * Unmute ADC0 and set the default input to mic-in
14287          */
14288         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14289         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14290
14291         /* Unmute DAC0~3 & spdif out*/
14292         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14293         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14294         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14295         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14296         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14297
14298         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14299         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14300         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14301         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14302         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14303
14304         /* Unmute Stereo Mixer 15 */
14305         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14306         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14307         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14308         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14309
14310         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14311         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14312         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14313         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14314         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14315         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14316         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14317         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14318
14319         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14320         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14321         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14322         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14323         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14324         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14325         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14326         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14327
14328         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14329
14330         { }
14331 };
14332
14333 static struct hda_verb alc861_toshiba_init_verbs[] = {
14334         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14335
14336         { }
14337 };
14338
14339 /* toggle speaker-output according to the hp-jack state */
14340 static void alc861_toshiba_automute(struct hda_codec *codec)
14341 {
14342         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14343
14344         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14345                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14346         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14347                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14348 }
14349
14350 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14351                                        unsigned int res)
14352 {
14353         if ((res >> 26) == ALC880_HP_EVENT)
14354                 alc861_toshiba_automute(codec);
14355 }
14356
14357 /* pcm configuration: identical with ALC880 */
14358 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14359 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14360 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14361 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14362
14363
14364 #define ALC861_DIGOUT_NID       0x07
14365
14366 static struct hda_channel_mode alc861_8ch_modes[1] = {
14367         { 8, NULL }
14368 };
14369
14370 static hda_nid_t alc861_dac_nids[4] = {
14371         /* front, surround, clfe, side */
14372         0x03, 0x06, 0x05, 0x04
14373 };
14374
14375 static hda_nid_t alc660_dac_nids[3] = {
14376         /* front, clfe, surround */
14377         0x03, 0x05, 0x06
14378 };
14379
14380 static hda_nid_t alc861_adc_nids[1] = {
14381         /* ADC0-2 */
14382         0x08,
14383 };
14384
14385 static struct hda_input_mux alc861_capture_source = {
14386         .num_items = 5,
14387         .items = {
14388                 { "Mic", 0x0 },
14389                 { "Front Mic", 0x3 },
14390                 { "Line", 0x1 },
14391                 { "CD", 0x4 },
14392                 { "Mixer", 0x5 },
14393         },
14394 };
14395
14396 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14397 {
14398         struct alc_spec *spec = codec->spec;
14399         hda_nid_t mix, srcs[5];
14400         int i, j, num;
14401
14402         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14403                 return 0;
14404         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14405         if (num < 0)
14406                 return 0;
14407         for (i = 0; i < num; i++) {
14408                 unsigned int type;
14409                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14410                 if (type != AC_WID_AUD_OUT)
14411                         continue;
14412                 for (j = 0; j < spec->multiout.num_dacs; j++)
14413                         if (spec->multiout.dac_nids[j] == srcs[i])
14414                                 break;
14415                 if (j >= spec->multiout.num_dacs)
14416                         return srcs[i];
14417         }
14418         return 0;
14419 }
14420
14421 /* fill in the dac_nids table from the parsed pin configuration */
14422 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14423                                      const struct auto_pin_cfg *cfg)
14424 {
14425         struct alc_spec *spec = codec->spec;
14426         int i;
14427         hda_nid_t nid, dac;
14428
14429         spec->multiout.dac_nids = spec->private_dac_nids;
14430         for (i = 0; i < cfg->line_outs; i++) {
14431                 nid = cfg->line_out_pins[i];
14432                 dac = alc861_look_for_dac(codec, nid);
14433                 if (!dac)
14434                         continue;
14435                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14436         }
14437         return 0;
14438 }
14439
14440 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14441                                 hda_nid_t nid, unsigned int chs)
14442 {
14443         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14444                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14445 }
14446
14447 /* add playback controls from the parsed DAC table */
14448 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14449                                              const struct auto_pin_cfg *cfg)
14450 {
14451         struct alc_spec *spec = codec->spec;
14452         static const char *chname[4] = {
14453                 "Front", "Surround", NULL /*CLFE*/, "Side"
14454         };
14455         hda_nid_t nid;
14456         int i, err;
14457
14458         if (cfg->line_outs == 1) {
14459                 const char *pfx = NULL;
14460                 if (!cfg->hp_outs)
14461                         pfx = "Master";
14462                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14463                         pfx = "Speaker";
14464                 if (pfx) {
14465                         nid = spec->multiout.dac_nids[0];
14466                         return alc861_create_out_sw(codec, pfx, nid, 3);
14467                 }
14468         }
14469
14470         for (i = 0; i < cfg->line_outs; i++) {
14471                 nid = spec->multiout.dac_nids[i];
14472                 if (!nid)
14473                         continue;
14474                 if (i == 2) {
14475                         /* Center/LFE */
14476                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14477                         if (err < 0)
14478                                 return err;
14479                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14480                         if (err < 0)
14481                                 return err;
14482                 } else {
14483                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14484                         if (err < 0)
14485                                 return err;
14486                 }
14487         }
14488         return 0;
14489 }
14490
14491 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14492 {
14493         struct alc_spec *spec = codec->spec;
14494         int err;
14495         hda_nid_t nid;
14496
14497         if (!pin)
14498                 return 0;
14499
14500         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14501                 nid = alc861_look_for_dac(codec, pin);
14502                 if (nid) {
14503                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14504                         if (err < 0)
14505                                 return err;
14506                         spec->multiout.hp_nid = nid;
14507                 }
14508         }
14509         return 0;
14510 }
14511
14512 /* create playback/capture controls for input pins */
14513 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14514                                                 const struct auto_pin_cfg *cfg)
14515 {
14516         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14517 }
14518
14519 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14520                                               hda_nid_t nid,
14521                                               int pin_type, hda_nid_t dac)
14522 {
14523         hda_nid_t mix, srcs[5];
14524         int i, num;
14525
14526         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14527                             pin_type);
14528         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14529                             AMP_OUT_UNMUTE);
14530         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14531                 return;
14532         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14533         if (num < 0)
14534                 return;
14535         for (i = 0; i < num; i++) {
14536                 unsigned int mute;
14537                 if (srcs[i] == dac || srcs[i] == 0x15)
14538                         mute = AMP_IN_UNMUTE(i);
14539                 else
14540                         mute = AMP_IN_MUTE(i);
14541                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14542                                     mute);
14543         }
14544 }
14545
14546 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14547 {
14548         struct alc_spec *spec = codec->spec;
14549         int i;
14550
14551         for (i = 0; i < spec->autocfg.line_outs; i++) {
14552                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14553                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14554                 if (nid)
14555                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14556                                                           spec->multiout.dac_nids[i]);
14557         }
14558 }
14559
14560 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14561 {
14562         struct alc_spec *spec = codec->spec;
14563
14564         if (spec->autocfg.hp_outs)
14565                 alc861_auto_set_output_and_unmute(codec,
14566                                                   spec->autocfg.hp_pins[0],
14567                                                   PIN_HP,
14568                                                   spec->multiout.hp_nid);
14569         if (spec->autocfg.speaker_outs)
14570                 alc861_auto_set_output_and_unmute(codec,
14571                                                   spec->autocfg.speaker_pins[0],
14572                                                   PIN_OUT,
14573                                                   spec->multiout.dac_nids[0]);
14574 }
14575
14576 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14577 {
14578         struct alc_spec *spec = codec->spec;
14579         int i;
14580
14581         for (i = 0; i < AUTO_PIN_LAST; i++) {
14582                 hda_nid_t nid = spec->autocfg.input_pins[i];
14583                 if (nid >= 0x0c && nid <= 0x11)
14584                         alc_set_input_pin(codec, nid, i);
14585         }
14586 }
14587
14588 /* parse the BIOS configuration and set up the alc_spec */
14589 /* return 1 if successful, 0 if the proper config is not found,
14590  * or a negative error code
14591  */
14592 static int alc861_parse_auto_config(struct hda_codec *codec)
14593 {
14594         struct alc_spec *spec = codec->spec;
14595         int err;
14596         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14597
14598         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14599                                            alc861_ignore);
14600         if (err < 0)
14601                 return err;
14602         if (!spec->autocfg.line_outs)
14603                 return 0; /* can't find valid BIOS pin config */
14604
14605         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14606         if (err < 0)
14607                 return err;
14608         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14609         if (err < 0)
14610                 return err;
14611         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14612         if (err < 0)
14613                 return err;
14614         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14615         if (err < 0)
14616                 return err;
14617
14618         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14619
14620         if (spec->autocfg.dig_outs)
14621                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14622
14623         if (spec->kctls.list)
14624                 add_mixer(spec, spec->kctls.list);
14625
14626         add_verb(spec, alc861_auto_init_verbs);
14627
14628         spec->num_mux_defs = 1;
14629         spec->input_mux = &spec->private_imux[0];
14630
14631         spec->adc_nids = alc861_adc_nids;
14632         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14633         set_capture_mixer(codec);
14634
14635         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14636
14637         return 1;
14638 }
14639
14640 /* additional initialization for auto-configuration model */
14641 static void alc861_auto_init(struct hda_codec *codec)
14642 {
14643         struct alc_spec *spec = codec->spec;
14644         alc861_auto_init_multi_out(codec);
14645         alc861_auto_init_hp_out(codec);
14646         alc861_auto_init_analog_input(codec);
14647         if (spec->unsol_event)
14648                 alc_inithook(codec);
14649 }
14650
14651 #ifdef CONFIG_SND_HDA_POWER_SAVE
14652 static struct hda_amp_list alc861_loopbacks[] = {
14653         { 0x15, HDA_INPUT, 0 },
14654         { 0x15, HDA_INPUT, 1 },
14655         { 0x15, HDA_INPUT, 2 },
14656         { 0x15, HDA_INPUT, 3 },
14657         { } /* end */
14658 };
14659 #endif
14660
14661
14662 /*
14663  * configuration and preset
14664  */
14665 static const char *alc861_models[ALC861_MODEL_LAST] = {
14666         [ALC861_3ST]            = "3stack",
14667         [ALC660_3ST]            = "3stack-660",
14668         [ALC861_3ST_DIG]        = "3stack-dig",
14669         [ALC861_6ST_DIG]        = "6stack-dig",
14670         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14671         [ALC861_TOSHIBA]        = "toshiba",
14672         [ALC861_ASUS]           = "asus",
14673         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14674         [ALC861_AUTO]           = "auto",
14675 };
14676
14677 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14678         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14679         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14680         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14681         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14682         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14683         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14684         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14685         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14686          *        Any other models that need this preset?
14687          */
14688         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14689         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14690         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14691         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14692         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14693         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14694         /* FIXME: the below seems conflict */
14695         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14696         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14697         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14698         {}
14699 };
14700
14701 static struct alc_config_preset alc861_presets[] = {
14702         [ALC861_3ST] = {
14703                 .mixers = { alc861_3ST_mixer },
14704                 .init_verbs = { alc861_threestack_init_verbs },
14705                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14706                 .dac_nids = alc861_dac_nids,
14707                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14708                 .channel_mode = alc861_threestack_modes,
14709                 .need_dac_fix = 1,
14710                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14711                 .adc_nids = alc861_adc_nids,
14712                 .input_mux = &alc861_capture_source,
14713         },
14714         [ALC861_3ST_DIG] = {
14715                 .mixers = { alc861_base_mixer },
14716                 .init_verbs = { alc861_threestack_init_verbs },
14717                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14718                 .dac_nids = alc861_dac_nids,
14719                 .dig_out_nid = ALC861_DIGOUT_NID,
14720                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14721                 .channel_mode = alc861_threestack_modes,
14722                 .need_dac_fix = 1,
14723                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14724                 .adc_nids = alc861_adc_nids,
14725                 .input_mux = &alc861_capture_source,
14726         },
14727         [ALC861_6ST_DIG] = {
14728                 .mixers = { alc861_base_mixer },
14729                 .init_verbs = { alc861_base_init_verbs },
14730                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14731                 .dac_nids = alc861_dac_nids,
14732                 .dig_out_nid = ALC861_DIGOUT_NID,
14733                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14734                 .channel_mode = alc861_8ch_modes,
14735                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14736                 .adc_nids = alc861_adc_nids,
14737                 .input_mux = &alc861_capture_source,
14738         },
14739         [ALC660_3ST] = {
14740                 .mixers = { alc861_3ST_mixer },
14741                 .init_verbs = { alc861_threestack_init_verbs },
14742                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14743                 .dac_nids = alc660_dac_nids,
14744                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14745                 .channel_mode = alc861_threestack_modes,
14746                 .need_dac_fix = 1,
14747                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14748                 .adc_nids = alc861_adc_nids,
14749                 .input_mux = &alc861_capture_source,
14750         },
14751         [ALC861_UNIWILL_M31] = {
14752                 .mixers = { alc861_uniwill_m31_mixer },
14753                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14754                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14755                 .dac_nids = alc861_dac_nids,
14756                 .dig_out_nid = ALC861_DIGOUT_NID,
14757                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14758                 .channel_mode = alc861_uniwill_m31_modes,
14759                 .need_dac_fix = 1,
14760                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14761                 .adc_nids = alc861_adc_nids,
14762                 .input_mux = &alc861_capture_source,
14763         },
14764         [ALC861_TOSHIBA] = {
14765                 .mixers = { alc861_toshiba_mixer },
14766                 .init_verbs = { alc861_base_init_verbs,
14767                                 alc861_toshiba_init_verbs },
14768                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14769                 .dac_nids = alc861_dac_nids,
14770                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14771                 .channel_mode = alc883_3ST_2ch_modes,
14772                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14773                 .adc_nids = alc861_adc_nids,
14774                 .input_mux = &alc861_capture_source,
14775                 .unsol_event = alc861_toshiba_unsol_event,
14776                 .init_hook = alc861_toshiba_automute,
14777         },
14778         [ALC861_ASUS] = {
14779                 .mixers = { alc861_asus_mixer },
14780                 .init_verbs = { alc861_asus_init_verbs },
14781                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14782                 .dac_nids = alc861_dac_nids,
14783                 .dig_out_nid = ALC861_DIGOUT_NID,
14784                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14785                 .channel_mode = alc861_asus_modes,
14786                 .need_dac_fix = 1,
14787                 .hp_nid = 0x06,
14788                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14789                 .adc_nids = alc861_adc_nids,
14790                 .input_mux = &alc861_capture_source,
14791         },
14792         [ALC861_ASUS_LAPTOP] = {
14793                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14794                 .init_verbs = { alc861_asus_init_verbs,
14795                                 alc861_asus_laptop_init_verbs },
14796                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14797                 .dac_nids = alc861_dac_nids,
14798                 .dig_out_nid = ALC861_DIGOUT_NID,
14799                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14800                 .channel_mode = alc883_3ST_2ch_modes,
14801                 .need_dac_fix = 1,
14802                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14803                 .adc_nids = alc861_adc_nids,
14804                 .input_mux = &alc861_capture_source,
14805         },
14806 };
14807
14808 /* Pin config fixes */
14809 enum {
14810         PINFIX_FSC_AMILO_PI1505,
14811 };
14812
14813 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
14814         { 0x0b, 0x0221101f }, /* HP */
14815         { 0x0f, 0x90170310 }, /* speaker */
14816         { }
14817 };
14818
14819 static const struct alc_fixup alc861_fixups[] = {
14820         [PINFIX_FSC_AMILO_PI1505] = {
14821                 .pins = alc861_fsc_amilo_pi1505_pinfix
14822         },
14823 };
14824
14825 static struct snd_pci_quirk alc861_fixup_tbl[] = {
14826         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
14827         {}
14828 };
14829
14830 static int patch_alc861(struct hda_codec *codec)
14831 {
14832         struct alc_spec *spec;
14833         int board_config;
14834         int err;
14835
14836         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14837         if (spec == NULL)
14838                 return -ENOMEM;
14839
14840         codec->spec = spec;
14841
14842         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14843                                                   alc861_models,
14844                                                   alc861_cfg_tbl);
14845
14846         if (board_config < 0) {
14847                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14848                        codec->chip_name);
14849                 board_config = ALC861_AUTO;
14850         }
14851
14852         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
14853
14854         if (board_config == ALC861_AUTO) {
14855                 /* automatic parse from the BIOS config */
14856                 err = alc861_parse_auto_config(codec);
14857                 if (err < 0) {
14858                         alc_free(codec);
14859                         return err;
14860                 } else if (!err) {
14861                         printk(KERN_INFO
14862                                "hda_codec: Cannot set up configuration "
14863                                "from BIOS.  Using base mode...\n");
14864                    board_config = ALC861_3ST_DIG;
14865                 }
14866         }
14867
14868         err = snd_hda_attach_beep_device(codec, 0x23);
14869         if (err < 0) {
14870                 alc_free(codec);
14871                 return err;
14872         }
14873
14874         if (board_config != ALC861_AUTO)
14875                 setup_preset(codec, &alc861_presets[board_config]);
14876
14877         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14878         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14879
14880         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14881         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14882
14883         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14884
14885         spec->vmaster_nid = 0x03;
14886
14887         codec->patch_ops = alc_patch_ops;
14888         if (board_config == ALC861_AUTO)
14889                 spec->init_hook = alc861_auto_init;
14890 #ifdef CONFIG_SND_HDA_POWER_SAVE
14891         if (!spec->loopback.amplist)
14892                 spec->loopback.amplist = alc861_loopbacks;
14893 #endif
14894         codec->proc_widget_hook = print_realtek_coef;
14895
14896         return 0;
14897 }
14898
14899 /*
14900  * ALC861-VD support
14901  *
14902  * Based on ALC882
14903  *
14904  * In addition, an independent DAC
14905  */
14906 #define ALC861VD_DIGOUT_NID     0x06
14907
14908 static hda_nid_t alc861vd_dac_nids[4] = {
14909         /* front, surr, clfe, side surr */
14910         0x02, 0x03, 0x04, 0x05
14911 };
14912
14913 /* dac_nids for ALC660vd are in a different order - according to
14914  * Realtek's driver.
14915  * This should probably result in a different mixer for 6stack models
14916  * of ALC660vd codecs, but for now there is only 3stack mixer
14917  * - and it is the same as in 861vd.
14918  * adc_nids in ALC660vd are (is) the same as in 861vd
14919  */
14920 static hda_nid_t alc660vd_dac_nids[3] = {
14921         /* front, rear, clfe, rear_surr */
14922         0x02, 0x04, 0x03
14923 };
14924
14925 static hda_nid_t alc861vd_adc_nids[1] = {
14926         /* ADC0 */
14927         0x09,
14928 };
14929
14930 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14931
14932 /* input MUX */
14933 /* FIXME: should be a matrix-type input source selection */
14934 static struct hda_input_mux alc861vd_capture_source = {
14935         .num_items = 4,
14936         .items = {
14937                 { "Mic", 0x0 },
14938                 { "Front Mic", 0x1 },
14939                 { "Line", 0x2 },
14940                 { "CD", 0x4 },
14941         },
14942 };
14943
14944 static struct hda_input_mux alc861vd_dallas_capture_source = {
14945         .num_items = 2,
14946         .items = {
14947                 { "Ext Mic", 0x0 },
14948                 { "Int Mic", 0x1 },
14949         },
14950 };
14951
14952 static struct hda_input_mux alc861vd_hp_capture_source = {
14953         .num_items = 2,
14954         .items = {
14955                 { "Front Mic", 0x0 },
14956                 { "ATAPI Mic", 0x1 },
14957         },
14958 };
14959
14960 /*
14961  * 2ch mode
14962  */
14963 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14964         { 2, NULL }
14965 };
14966
14967 /*
14968  * 6ch mode
14969  */
14970 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14971         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14972         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14973         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14974         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14975         { } /* end */
14976 };
14977
14978 /*
14979  * 8ch mode
14980  */
14981 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14982         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14983         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14984         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14985         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14986         { } /* end */
14987 };
14988
14989 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14990         { 6, alc861vd_6stack_ch6_init },
14991         { 8, alc861vd_6stack_ch8_init },
14992 };
14993
14994 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14995         {
14996                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14997                 .name = "Channel Mode",
14998                 .info = alc_ch_mode_info,
14999                 .get = alc_ch_mode_get,
15000                 .put = alc_ch_mode_put,
15001         },
15002         { } /* end */
15003 };
15004
15005 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15006  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15007  */
15008 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15009         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15010         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15011
15012         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15013         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15014
15015         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15016                                 HDA_OUTPUT),
15017         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15018                                 HDA_OUTPUT),
15019         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15020         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15021
15022         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15023         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15024
15025         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15026
15027         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15028         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15029         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15030
15031         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15032         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15033         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15034
15035         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15036         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15037
15038         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15039         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15040
15041         { } /* end */
15042 };
15043
15044 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15045         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15046         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15047
15048         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15049
15050         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15051         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15052         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15053
15054         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15055         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15056         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15057
15058         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15059         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15060
15061         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15062         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15063
15064         { } /* end */
15065 };
15066
15067 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15068         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15069         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15070         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15071
15072         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15073
15074         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15075         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15076         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15077
15078         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15079         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15080         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15081
15082         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15083         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15084
15085         { } /* end */
15086 };
15087
15088 /* Pin assignment: Speaker=0x14, HP = 0x15,
15089  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15090  */
15091 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15092         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15093         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15094         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15095         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15096         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15097         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15098         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15099         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15100         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15101         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15102         { } /* end */
15103 };
15104
15105 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15106  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15107  */
15108 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15109         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15110         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15111         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15112         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15113         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15114         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15115         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15116         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15117
15118         { } /* end */
15119 };
15120
15121 /*
15122  * generic initialization of ADC, input mixers and output mixers
15123  */
15124 static struct hda_verb alc861vd_volume_init_verbs[] = {
15125         /*
15126          * Unmute ADC0 and set the default input to mic-in
15127          */
15128         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15129         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15130
15131         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15132          * the analog-loopback mixer widget
15133          */
15134         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15135         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15136         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15137         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15138         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15139         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15140
15141         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15142         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15143         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15144         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15145         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15146
15147         /*
15148          * Set up output mixers (0x02 - 0x05)
15149          */
15150         /* set vol=0 to output mixers */
15151         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15152         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15153         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15154         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15155
15156         /* set up input amps for analog loopback */
15157         /* Amp Indices: DAC = 0, mixer = 1 */
15158         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15159         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15160         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15161         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15162         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15163         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15164         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15165         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15166
15167         { }
15168 };
15169
15170 /*
15171  * 3-stack pin configuration:
15172  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15173  */
15174 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15175         /*
15176          * Set pin mode and muting
15177          */
15178         /* set front pin widgets 0x14 for output */
15179         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15180         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15181         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15182
15183         /* Mic (rear) pin: input vref at 80% */
15184         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15185         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15186         /* Front Mic pin: input vref at 80% */
15187         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15188         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15189         /* Line In pin: input */
15190         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15191         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15192         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15193         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15194         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15195         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15196         /* CD pin widget for input */
15197         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15198
15199         { }
15200 };
15201
15202 /*
15203  * 6-stack pin configuration:
15204  */
15205 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15206         /*
15207          * Set pin mode and muting
15208          */
15209         /* set front pin widgets 0x14 for output */
15210         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15211         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15212         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15213
15214         /* Rear Pin: output 1 (0x0d) */
15215         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15216         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15217         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15218         /* CLFE Pin: output 2 (0x0e) */
15219         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15220         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15221         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15222         /* Side Pin: output 3 (0x0f) */
15223         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15224         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15225         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15226
15227         /* Mic (rear) pin: input vref at 80% */
15228         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15229         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15230         /* Front Mic pin: input vref at 80% */
15231         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15232         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15233         /* Line In pin: input */
15234         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15235         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15236         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15237         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15238         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15239         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15240         /* CD pin widget for input */
15241         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15242
15243         { }
15244 };
15245
15246 static struct hda_verb alc861vd_eapd_verbs[] = {
15247         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15248         { }
15249 };
15250
15251 static struct hda_verb alc660vd_eapd_verbs[] = {
15252         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15253         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15254         { }
15255 };
15256
15257 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15258         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15259         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15260         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15261         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15262         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15263         {}
15264 };
15265
15266 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15267 {
15268         unsigned int present;
15269         unsigned char bits;
15270
15271         present = snd_hda_jack_detect(codec, 0x18);
15272         bits = present ? HDA_AMP_MUTE : 0;
15273
15274         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15275                                  HDA_AMP_MUTE, bits);
15276 }
15277
15278 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15279 {
15280         struct alc_spec *spec = codec->spec;
15281         spec->autocfg.hp_pins[0] = 0x1b;
15282         spec->autocfg.speaker_pins[0] = 0x14;
15283 }
15284
15285 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15286 {
15287         alc_automute_amp(codec);
15288         alc861vd_lenovo_mic_automute(codec);
15289 }
15290
15291 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15292                                         unsigned int res)
15293 {
15294         switch (res >> 26) {
15295         case ALC880_MIC_EVENT:
15296                 alc861vd_lenovo_mic_automute(codec);
15297                 break;
15298         default:
15299                 alc_automute_amp_unsol_event(codec, res);
15300                 break;
15301         }
15302 }
15303
15304 static struct hda_verb alc861vd_dallas_verbs[] = {
15305         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15306         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15307         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15308         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15309
15310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15311         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15312         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15313         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15314         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15315         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15316         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15317         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15318
15319         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15320         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15321         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15322         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15323         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15324         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15325         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15326         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15327
15328         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15329         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15330         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15331         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15332         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15333         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15334         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15335         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15336
15337         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15338         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15339         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15340         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15341
15342         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15343         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15344         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15345
15346         { } /* end */
15347 };
15348
15349 /* toggle speaker-output according to the hp-jack state */
15350 static void alc861vd_dallas_setup(struct hda_codec *codec)
15351 {
15352         struct alc_spec *spec = codec->spec;
15353
15354         spec->autocfg.hp_pins[0] = 0x15;
15355         spec->autocfg.speaker_pins[0] = 0x14;
15356 }
15357
15358 #ifdef CONFIG_SND_HDA_POWER_SAVE
15359 #define alc861vd_loopbacks      alc880_loopbacks
15360 #endif
15361
15362 /* pcm configuration: identical with ALC880 */
15363 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15364 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15365 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15366 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15367
15368 /*
15369  * configuration and preset
15370  */
15371 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15372         [ALC660VD_3ST]          = "3stack-660",
15373         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15374         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15375         [ALC861VD_3ST]          = "3stack",
15376         [ALC861VD_3ST_DIG]      = "3stack-digout",
15377         [ALC861VD_6ST_DIG]      = "6stack-digout",
15378         [ALC861VD_LENOVO]       = "lenovo",
15379         [ALC861VD_DALLAS]       = "dallas",
15380         [ALC861VD_HP]           = "hp",
15381         [ALC861VD_AUTO]         = "auto",
15382 };
15383
15384 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15385         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15386         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15387         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15388         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15389         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15390         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15391         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15392         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15393         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15394         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15395         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15396         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15397         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15398         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15399         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15400         {}
15401 };
15402
15403 static struct alc_config_preset alc861vd_presets[] = {
15404         [ALC660VD_3ST] = {
15405                 .mixers = { alc861vd_3st_mixer },
15406                 .init_verbs = { alc861vd_volume_init_verbs,
15407                                  alc861vd_3stack_init_verbs },
15408                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15409                 .dac_nids = alc660vd_dac_nids,
15410                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15411                 .channel_mode = alc861vd_3stack_2ch_modes,
15412                 .input_mux = &alc861vd_capture_source,
15413         },
15414         [ALC660VD_3ST_DIG] = {
15415                 .mixers = { alc861vd_3st_mixer },
15416                 .init_verbs = { alc861vd_volume_init_verbs,
15417                                  alc861vd_3stack_init_verbs },
15418                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15419                 .dac_nids = alc660vd_dac_nids,
15420                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15421                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15422                 .channel_mode = alc861vd_3stack_2ch_modes,
15423                 .input_mux = &alc861vd_capture_source,
15424         },
15425         [ALC861VD_3ST] = {
15426                 .mixers = { alc861vd_3st_mixer },
15427                 .init_verbs = { alc861vd_volume_init_verbs,
15428                                  alc861vd_3stack_init_verbs },
15429                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15430                 .dac_nids = alc861vd_dac_nids,
15431                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15432                 .channel_mode = alc861vd_3stack_2ch_modes,
15433                 .input_mux = &alc861vd_capture_source,
15434         },
15435         [ALC861VD_3ST_DIG] = {
15436                 .mixers = { alc861vd_3st_mixer },
15437                 .init_verbs = { alc861vd_volume_init_verbs,
15438                                  alc861vd_3stack_init_verbs },
15439                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15440                 .dac_nids = alc861vd_dac_nids,
15441                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15442                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15443                 .channel_mode = alc861vd_3stack_2ch_modes,
15444                 .input_mux = &alc861vd_capture_source,
15445         },
15446         [ALC861VD_6ST_DIG] = {
15447                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15448                 .init_verbs = { alc861vd_volume_init_verbs,
15449                                 alc861vd_6stack_init_verbs },
15450                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15451                 .dac_nids = alc861vd_dac_nids,
15452                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15453                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15454                 .channel_mode = alc861vd_6stack_modes,
15455                 .input_mux = &alc861vd_capture_source,
15456         },
15457         [ALC861VD_LENOVO] = {
15458                 .mixers = { alc861vd_lenovo_mixer },
15459                 .init_verbs = { alc861vd_volume_init_verbs,
15460                                 alc861vd_3stack_init_verbs,
15461                                 alc861vd_eapd_verbs,
15462                                 alc861vd_lenovo_unsol_verbs },
15463                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15464                 .dac_nids = alc660vd_dac_nids,
15465                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15466                 .channel_mode = alc861vd_3stack_2ch_modes,
15467                 .input_mux = &alc861vd_capture_source,
15468                 .unsol_event = alc861vd_lenovo_unsol_event,
15469                 .setup = alc861vd_lenovo_setup,
15470                 .init_hook = alc861vd_lenovo_init_hook,
15471         },
15472         [ALC861VD_DALLAS] = {
15473                 .mixers = { alc861vd_dallas_mixer },
15474                 .init_verbs = { alc861vd_dallas_verbs },
15475                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15476                 .dac_nids = alc861vd_dac_nids,
15477                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15478                 .channel_mode = alc861vd_3stack_2ch_modes,
15479                 .input_mux = &alc861vd_dallas_capture_source,
15480                 .unsol_event = alc_automute_amp_unsol_event,
15481                 .setup = alc861vd_dallas_setup,
15482                 .init_hook = alc_automute_amp,
15483         },
15484         [ALC861VD_HP] = {
15485                 .mixers = { alc861vd_hp_mixer },
15486                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15487                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15488                 .dac_nids = alc861vd_dac_nids,
15489                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15490                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15491                 .channel_mode = alc861vd_3stack_2ch_modes,
15492                 .input_mux = &alc861vd_hp_capture_source,
15493                 .unsol_event = alc_automute_amp_unsol_event,
15494                 .setup = alc861vd_dallas_setup,
15495                 .init_hook = alc_automute_amp,
15496         },
15497         [ALC660VD_ASUS_V1S] = {
15498                 .mixers = { alc861vd_lenovo_mixer },
15499                 .init_verbs = { alc861vd_volume_init_verbs,
15500                                 alc861vd_3stack_init_verbs,
15501                                 alc861vd_eapd_verbs,
15502                                 alc861vd_lenovo_unsol_verbs },
15503                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15504                 .dac_nids = alc660vd_dac_nids,
15505                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15506                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15507                 .channel_mode = alc861vd_3stack_2ch_modes,
15508                 .input_mux = &alc861vd_capture_source,
15509                 .unsol_event = alc861vd_lenovo_unsol_event,
15510                 .setup = alc861vd_lenovo_setup,
15511                 .init_hook = alc861vd_lenovo_init_hook,
15512         },
15513 };
15514
15515 /*
15516  * BIOS auto configuration
15517  */
15518 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15519                                                 const struct auto_pin_cfg *cfg)
15520 {
15521         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
15522 }
15523
15524
15525 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15526                                 hda_nid_t nid, int pin_type, int dac_idx)
15527 {
15528         alc_set_pin_output(codec, nid, pin_type);
15529 }
15530
15531 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15532 {
15533         struct alc_spec *spec = codec->spec;
15534         int i;
15535
15536         for (i = 0; i <= HDA_SIDE; i++) {
15537                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15538                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15539                 if (nid)
15540                         alc861vd_auto_set_output_and_unmute(codec, nid,
15541                                                             pin_type, i);
15542         }
15543 }
15544
15545
15546 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15547 {
15548         struct alc_spec *spec = codec->spec;
15549         hda_nid_t pin;
15550
15551         pin = spec->autocfg.hp_pins[0];
15552         if (pin) /* connect to front and use dac 0 */
15553                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15554         pin = spec->autocfg.speaker_pins[0];
15555         if (pin)
15556                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15557 }
15558
15559 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15560
15561 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15562 {
15563         struct alc_spec *spec = codec->spec;
15564         int i;
15565
15566         for (i = 0; i < AUTO_PIN_LAST; i++) {
15567                 hda_nid_t nid = spec->autocfg.input_pins[i];
15568                 if (alc_is_input_pin(codec, nid)) {
15569                         alc_set_input_pin(codec, nid, i);
15570                         if (nid != ALC861VD_PIN_CD_NID &&
15571                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15572                                 snd_hda_codec_write(codec, nid, 0,
15573                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15574                                                 AMP_OUT_MUTE);
15575                 }
15576         }
15577 }
15578
15579 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15580
15581 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15582 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15583
15584 /* add playback controls from the parsed DAC table */
15585 /* Based on ALC880 version. But ALC861VD has separate,
15586  * different NIDs for mute/unmute switch and volume control */
15587 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15588                                              const struct auto_pin_cfg *cfg)
15589 {
15590         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15591         hda_nid_t nid_v, nid_s;
15592         int i, err;
15593
15594         for (i = 0; i < cfg->line_outs; i++) {
15595                 if (!spec->multiout.dac_nids[i])
15596                         continue;
15597                 nid_v = alc861vd_idx_to_mixer_vol(
15598                                 alc880_dac_to_idx(
15599                                         spec->multiout.dac_nids[i]));
15600                 nid_s = alc861vd_idx_to_mixer_switch(
15601                                 alc880_dac_to_idx(
15602                                         spec->multiout.dac_nids[i]));
15603
15604                 if (i == 2) {
15605                         /* Center/LFE */
15606                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15607                                               "Center",
15608                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15609                                                               HDA_OUTPUT));
15610                         if (err < 0)
15611                                 return err;
15612                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
15613                                               "LFE",
15614                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15615                                                               HDA_OUTPUT));
15616                         if (err < 0)
15617                                 return err;
15618                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15619                                              "Center",
15620                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15621                                                               HDA_INPUT));
15622                         if (err < 0)
15623                                 return err;
15624                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
15625                                              "LFE",
15626                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15627                                                               HDA_INPUT));
15628                         if (err < 0)
15629                                 return err;
15630                 } else {
15631                         const char *pfx;
15632                         if (cfg->line_outs == 1 &&
15633                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15634                                 if (!cfg->hp_pins)
15635                                         pfx = "Speaker";
15636                                 else
15637                                         pfx = "PCM";
15638                         } else
15639                                 pfx = chname[i];
15640                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15641                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15642                                                               HDA_OUTPUT));
15643                         if (err < 0)
15644                                 return err;
15645                         if (cfg->line_outs == 1 &&
15646                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15647                                 pfx = "Speaker";
15648                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15649                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15650                                                               HDA_INPUT));
15651                         if (err < 0)
15652                                 return err;
15653                 }
15654         }
15655         return 0;
15656 }
15657
15658 /* add playback controls for speaker and HP outputs */
15659 /* Based on ALC880 version. But ALC861VD has separate,
15660  * different NIDs for mute/unmute switch and volume control */
15661 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15662                                         hda_nid_t pin, const char *pfx)
15663 {
15664         hda_nid_t nid_v, nid_s;
15665         int err;
15666
15667         if (!pin)
15668                 return 0;
15669
15670         if (alc880_is_fixed_pin(pin)) {
15671                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15672                 /* specify the DAC as the extra output */
15673                 if (!spec->multiout.hp_nid)
15674                         spec->multiout.hp_nid = nid_v;
15675                 else
15676                         spec->multiout.extra_out_nid[0] = nid_v;
15677                 /* control HP volume/switch on the output mixer amp */
15678                 nid_v = alc861vd_idx_to_mixer_vol(
15679                                 alc880_fixed_pin_idx(pin));
15680                 nid_s = alc861vd_idx_to_mixer_switch(
15681                                 alc880_fixed_pin_idx(pin));
15682
15683                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
15684                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15685                 if (err < 0)
15686                         return err;
15687                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
15688                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15689                 if (err < 0)
15690                         return err;
15691         } else if (alc880_is_multi_pin(pin)) {
15692                 /* set manual connection */
15693                 /* we have only a switch on HP-out PIN */
15694                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
15695                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15696                 if (err < 0)
15697                         return err;
15698         }
15699         return 0;
15700 }
15701
15702 /* parse the BIOS configuration and set up the alc_spec
15703  * return 1 if successful, 0 if the proper config is not found,
15704  * or a negative error code
15705  * Based on ALC880 version - had to change it to override
15706  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15707 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15708 {
15709         struct alc_spec *spec = codec->spec;
15710         int err;
15711         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15712
15713         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15714                                            alc861vd_ignore);
15715         if (err < 0)
15716                 return err;
15717         if (!spec->autocfg.line_outs)
15718                 return 0; /* can't find valid BIOS pin config */
15719
15720         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15721         if (err < 0)
15722                 return err;
15723         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15724         if (err < 0)
15725                 return err;
15726         err = alc861vd_auto_create_extra_out(spec,
15727                                              spec->autocfg.speaker_pins[0],
15728                                              "Speaker");
15729         if (err < 0)
15730                 return err;
15731         err = alc861vd_auto_create_extra_out(spec,
15732                                              spec->autocfg.hp_pins[0],
15733                                              "Headphone");
15734         if (err < 0)
15735                 return err;
15736         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15737         if (err < 0)
15738                 return err;
15739
15740         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15741
15742         if (spec->autocfg.dig_outs)
15743                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15744
15745         if (spec->kctls.list)
15746                 add_mixer(spec, spec->kctls.list);
15747
15748         add_verb(spec, alc861vd_volume_init_verbs);
15749
15750         spec->num_mux_defs = 1;
15751         spec->input_mux = &spec->private_imux[0];
15752
15753         err = alc_auto_add_mic_boost(codec);
15754         if (err < 0)
15755                 return err;
15756
15757         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15758
15759         return 1;
15760 }
15761
15762 /* additional initialization for auto-configuration model */
15763 static void alc861vd_auto_init(struct hda_codec *codec)
15764 {
15765         struct alc_spec *spec = codec->spec;
15766         alc861vd_auto_init_multi_out(codec);
15767         alc861vd_auto_init_hp_out(codec);
15768         alc861vd_auto_init_analog_input(codec);
15769         alc861vd_auto_init_input_src(codec);
15770         if (spec->unsol_event)
15771                 alc_inithook(codec);
15772 }
15773
15774 enum {
15775         ALC660VD_FIX_ASUS_GPIO1
15776 };
15777
15778 /* reset GPIO1 */
15779 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15780         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15781         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15782         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15783         { }
15784 };
15785
15786 static const struct alc_fixup alc861vd_fixups[] = {
15787         [ALC660VD_FIX_ASUS_GPIO1] = {
15788                 .verbs = alc660vd_fix_asus_gpio1_verbs,
15789         },
15790 };
15791
15792 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15793         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15794         {}
15795 };
15796
15797 static int patch_alc861vd(struct hda_codec *codec)
15798 {
15799         struct alc_spec *spec;
15800         int err, board_config;
15801
15802         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15803         if (spec == NULL)
15804                 return -ENOMEM;
15805
15806         codec->spec = spec;
15807
15808         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15809                                                   alc861vd_models,
15810                                                   alc861vd_cfg_tbl);
15811
15812         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15813                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15814                        codec->chip_name);
15815                 board_config = ALC861VD_AUTO;
15816         }
15817
15818         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15819
15820         if (board_config == ALC861VD_AUTO) {
15821                 /* automatic parse from the BIOS config */
15822                 err = alc861vd_parse_auto_config(codec);
15823                 if (err < 0) {
15824                         alc_free(codec);
15825                         return err;
15826                 } else if (!err) {
15827                         printk(KERN_INFO
15828                                "hda_codec: Cannot set up configuration "
15829                                "from BIOS.  Using base mode...\n");
15830                         board_config = ALC861VD_3ST;
15831                 }
15832         }
15833
15834         err = snd_hda_attach_beep_device(codec, 0x23);
15835         if (err < 0) {
15836                 alc_free(codec);
15837                 return err;
15838         }
15839
15840         if (board_config != ALC861VD_AUTO)
15841                 setup_preset(codec, &alc861vd_presets[board_config]);
15842
15843         if (codec->vendor_id == 0x10ec0660) {
15844                 /* always turn on EAPD */
15845                 add_verb(spec, alc660vd_eapd_verbs);
15846         }
15847
15848         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15849         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15850
15851         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15852         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15853
15854         if (!spec->adc_nids) {
15855                 spec->adc_nids = alc861vd_adc_nids;
15856                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15857         }
15858         if (!spec->capsrc_nids)
15859                 spec->capsrc_nids = alc861vd_capsrc_nids;
15860
15861         set_capture_mixer(codec);
15862         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15863
15864         spec->vmaster_nid = 0x02;
15865
15866         codec->patch_ops = alc_patch_ops;
15867
15868         if (board_config == ALC861VD_AUTO)
15869                 spec->init_hook = alc861vd_auto_init;
15870 #ifdef CONFIG_SND_HDA_POWER_SAVE
15871         if (!spec->loopback.amplist)
15872                 spec->loopback.amplist = alc861vd_loopbacks;
15873 #endif
15874         codec->proc_widget_hook = print_realtek_coef;
15875
15876         return 0;
15877 }
15878
15879 /*
15880  * ALC662 support
15881  *
15882  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15883  * configuration.  Each pin widget can choose any input DACs and a mixer.
15884  * Each ADC is connected from a mixer of all inputs.  This makes possible
15885  * 6-channel independent captures.
15886  *
15887  * In addition, an independent DAC for the multi-playback (not used in this
15888  * driver yet).
15889  */
15890 #define ALC662_DIGOUT_NID       0x06
15891 #define ALC662_DIGIN_NID        0x0a
15892
15893 static hda_nid_t alc662_dac_nids[4] = {
15894         /* front, rear, clfe, rear_surr */
15895         0x02, 0x03, 0x04
15896 };
15897
15898 static hda_nid_t alc272_dac_nids[2] = {
15899         0x02, 0x03
15900 };
15901
15902 static hda_nid_t alc662_adc_nids[2] = {
15903         /* ADC1-2 */
15904         0x09, 0x08
15905 };
15906
15907 static hda_nid_t alc272_adc_nids[1] = {
15908         /* ADC1-2 */
15909         0x08,
15910 };
15911
15912 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15913 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15914
15915
15916 /* input MUX */
15917 /* FIXME: should be a matrix-type input source selection */
15918 static struct hda_input_mux alc662_capture_source = {
15919         .num_items = 4,
15920         .items = {
15921                 { "Mic", 0x0 },
15922                 { "Front Mic", 0x1 },
15923                 { "Line", 0x2 },
15924                 { "CD", 0x4 },
15925         },
15926 };
15927
15928 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15929         .num_items = 2,
15930         .items = {
15931                 { "Mic", 0x1 },
15932                 { "Line", 0x2 },
15933         },
15934 };
15935
15936 static struct hda_input_mux alc663_capture_source = {
15937         .num_items = 3,
15938         .items = {
15939                 { "Mic", 0x0 },
15940                 { "Front Mic", 0x1 },
15941                 { "Line", 0x2 },
15942         },
15943 };
15944
15945 #if 0 /* set to 1 for testing other input sources below */
15946 static struct hda_input_mux alc272_nc10_capture_source = {
15947         .num_items = 16,
15948         .items = {
15949                 { "Autoselect Mic", 0x0 },
15950                 { "Internal Mic", 0x1 },
15951                 { "In-0x02", 0x2 },
15952                 { "In-0x03", 0x3 },
15953                 { "In-0x04", 0x4 },
15954                 { "In-0x05", 0x5 },
15955                 { "In-0x06", 0x6 },
15956                 { "In-0x07", 0x7 },
15957                 { "In-0x08", 0x8 },
15958                 { "In-0x09", 0x9 },
15959                 { "In-0x0a", 0x0a },
15960                 { "In-0x0b", 0x0b },
15961                 { "In-0x0c", 0x0c },
15962                 { "In-0x0d", 0x0d },
15963                 { "In-0x0e", 0x0e },
15964                 { "In-0x0f", 0x0f },
15965         },
15966 };
15967 #endif
15968
15969 /*
15970  * 2ch mode
15971  */
15972 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15973         { 2, NULL }
15974 };
15975
15976 /*
15977  * 2ch mode
15978  */
15979 static struct hda_verb alc662_3ST_ch2_init[] = {
15980         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15981         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15982         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15983         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15984         { } /* end */
15985 };
15986
15987 /*
15988  * 6ch mode
15989  */
15990 static struct hda_verb alc662_3ST_ch6_init[] = {
15991         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15992         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15993         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15994         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15995         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15996         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15997         { } /* end */
15998 };
15999
16000 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16001         { 2, alc662_3ST_ch2_init },
16002         { 6, alc662_3ST_ch6_init },
16003 };
16004
16005 /*
16006  * 2ch mode
16007  */
16008 static struct hda_verb alc662_sixstack_ch6_init[] = {
16009         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16010         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16011         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16012         { } /* end */
16013 };
16014
16015 /*
16016  * 6ch mode
16017  */
16018 static struct hda_verb alc662_sixstack_ch8_init[] = {
16019         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16020         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16021         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16022         { } /* end */
16023 };
16024
16025 static struct hda_channel_mode alc662_5stack_modes[2] = {
16026         { 2, alc662_sixstack_ch6_init },
16027         { 6, alc662_sixstack_ch8_init },
16028 };
16029
16030 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16031  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16032  */
16033
16034 static struct snd_kcontrol_new alc662_base_mixer[] = {
16035         /* output mixer control */
16036         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16037         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16038         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16039         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16040         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16041         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16042         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16043         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16044         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16045
16046         /*Input mixer control */
16047         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16048         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16049         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16050         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16051         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16052         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16053         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16054         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16055         { } /* end */
16056 };
16057
16058 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16059         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16060         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16061         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16062         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16063         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16064         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16065         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16066         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16067         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16068         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16069         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16070         { } /* end */
16071 };
16072
16073 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16074         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16075         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16076         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16077         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16078         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16079         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16080         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16081         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16082         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16083         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16084         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16085         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16086         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16087         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16088         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16089         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16090         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16091         { } /* end */
16092 };
16093
16094 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16095         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16096         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16097         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16098         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16099         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16100         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16101         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16102         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16103         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16104         { } /* end */
16105 };
16106
16107 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16108         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16109         ALC262_HIPPO_MASTER_SWITCH,
16110
16111         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16112         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16113         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16114
16115         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16116         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16117         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16118         { } /* end */
16119 };
16120
16121 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16122         ALC262_HIPPO_MASTER_SWITCH,
16123         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16124         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16125         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16126         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16127         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16128         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16129         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16130         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16131         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16132         { } /* end */
16133 };
16134
16135 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16136         .ops = &snd_hda_bind_vol,
16137         .values = {
16138                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16139                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16140                 0
16141         },
16142 };
16143
16144 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16145         .ops = &snd_hda_bind_sw,
16146         .values = {
16147                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16148                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16149                 0
16150         },
16151 };
16152
16153 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16154         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16155         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16156         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16157         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16158         { } /* end */
16159 };
16160
16161 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16162         .ops = &snd_hda_bind_sw,
16163         .values = {
16164                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16165                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16166                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16167                 0
16168         },
16169 };
16170
16171 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16172         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16173         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16174         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16175         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16176         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16177         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16178
16179         { } /* end */
16180 };
16181
16182 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16183         .ops = &snd_hda_bind_sw,
16184         .values = {
16185                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16186                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16187                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16188                 0
16189         },
16190 };
16191
16192 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16193         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16194         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16195         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16196         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16197         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16198         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16199         { } /* end */
16200 };
16201
16202 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16203         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16204         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16205         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16206         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16207         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16208         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16209         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16210         { } /* end */
16211 };
16212
16213 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16214         .ops = &snd_hda_bind_vol,
16215         .values = {
16216                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16217                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16218                 0
16219         },
16220 };
16221
16222 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16223         .ops = &snd_hda_bind_sw,
16224         .values = {
16225                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16226                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16227                 0
16228         },
16229 };
16230
16231 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16232         HDA_BIND_VOL("Master Playback Volume",
16233                                 &alc663_asus_two_bind_master_vol),
16234         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16235         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16236         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16237         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16238         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16239         { } /* end */
16240 };
16241
16242 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16243         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16244         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16245         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16246         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16247         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16248         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16249         { } /* end */
16250 };
16251
16252 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16253         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16254         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16255         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16256         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16257         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16258
16259         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16260         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16261         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16262         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16263         { } /* end */
16264 };
16265
16266 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16267         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16268         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16269         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16270
16271         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16272         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16273         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16274         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16275         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16276         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16277         { } /* end */
16278 };
16279
16280 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16281         {
16282                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16283                 .name = "Channel Mode",
16284                 .info = alc_ch_mode_info,
16285                 .get = alc_ch_mode_get,
16286                 .put = alc_ch_mode_put,
16287         },
16288         { } /* end */
16289 };
16290
16291 static struct hda_verb alc662_init_verbs[] = {
16292         /* ADC: mute amp left and right */
16293         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16294         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16295         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16296
16297         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16298         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16299         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16300         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16301         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16302
16303         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16304         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16305         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16306         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16307         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16308         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16309
16310         /* Front Pin: output 0 (0x0c) */
16311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16312         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16313
16314         /* Rear Pin: output 1 (0x0d) */
16315         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16316         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16317
16318         /* CLFE Pin: output 2 (0x0e) */
16319         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16320         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16321
16322         /* Mic (rear) pin: input vref at 80% */
16323         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16324         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16325         /* Front Mic pin: input vref at 80% */
16326         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16327         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16328         /* Line In pin: input */
16329         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16330         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16331         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16332         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16333         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16334         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16335         /* CD pin widget for input */
16336         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16337
16338         /* FIXME: use matrix-type input source selection */
16339         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16340         /* Input mixer */
16341         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16342         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16343
16344         /* always trun on EAPD */
16345         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16346         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16347
16348         { }
16349 };
16350
16351 static struct hda_verb alc662_sue_init_verbs[] = {
16352         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16353         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16354         {}
16355 };
16356
16357 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16358         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16359         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16360         {}
16361 };
16362
16363 /* Set Unsolicited Event*/
16364 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16365         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16366         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16367         {}
16368 };
16369
16370 /*
16371  * generic initialization of ADC, input mixers and output mixers
16372  */
16373 static struct hda_verb alc662_auto_init_verbs[] = {
16374         /*
16375          * Unmute ADC and set the default input to mic-in
16376          */
16377         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16378         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16379
16380         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16381          * mixer widget
16382          * Note: PASD motherboards uses the Line In 2 as the input for front
16383          * panel mic (mic 2)
16384          */
16385         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16386         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16387         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16388         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16389         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16390         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16391
16392         /*
16393          * Set up output mixers (0x0c - 0x0f)
16394          */
16395         /* set vol=0 to output mixers */
16396         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16397         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16398         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16399
16400         /* set up input amps for analog loopback */
16401         /* Amp Indices: DAC = 0, mixer = 1 */
16402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16404         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16405         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16406         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16407         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16408
16409
16410         /* FIXME: use matrix-type input source selection */
16411         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16412         /* Input mixer */
16413         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16414         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16415         { }
16416 };
16417
16418 /* additional verbs for ALC663 */
16419 static struct hda_verb alc663_auto_init_verbs[] = {
16420         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16421         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16422         { }
16423 };
16424
16425 static struct hda_verb alc663_m51va_init_verbs[] = {
16426         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16427         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16428         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16429         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16430         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16431         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16432         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16433         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16434         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16435         {}
16436 };
16437
16438 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16439         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16440         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16441         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16442         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16443         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16444         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16445         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16446         {}
16447 };
16448
16449 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16450         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16451         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16452         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16453         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16454         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16455         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16456         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16457         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16458         {}
16459 };
16460
16461 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16462         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16463         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16464         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16465         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16466         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16467         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16468         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16469         {}
16470 };
16471
16472 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16473         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16474         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16475         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16476         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16477         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16478         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16479         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16480         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16481         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16482         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16483         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16484         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16485         {}
16486 };
16487
16488 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16489         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16490         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16491         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16492         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16493         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16494         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16495         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16496         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16497         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16498         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16499         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16500         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16501         {}
16502 };
16503
16504 static struct hda_verb alc663_g71v_init_verbs[] = {
16505         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16506         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16507         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16508
16509         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16510         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16511         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16512
16513         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16514         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16515         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16516         {}
16517 };
16518
16519 static struct hda_verb alc663_g50v_init_verbs[] = {
16520         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16521         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16522         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16523
16524         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16525         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16526         {}
16527 };
16528
16529 static struct hda_verb alc662_ecs_init_verbs[] = {
16530         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16531         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16532         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16533         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16534         {}
16535 };
16536
16537 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16538         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16539         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16540         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16541         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16542         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16543         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16544         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16545         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16546         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16547         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16548         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16549         {}
16550 };
16551
16552 static struct hda_verb alc272_dell_init_verbs[] = {
16553         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16554         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16555         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16556         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16557         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16558         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16559         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16560         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16561         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16562         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16563         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16564         {}
16565 };
16566
16567 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16568         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16569         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16570         { } /* end */
16571 };
16572
16573 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16574         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16575         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16576         { } /* end */
16577 };
16578
16579 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16580 {
16581         unsigned int present;
16582         unsigned char bits;
16583
16584         present = snd_hda_jack_detect(codec, 0x14);
16585         bits = present ? HDA_AMP_MUTE : 0;
16586
16587         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16588                                  HDA_AMP_MUTE, bits);
16589 }
16590
16591 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16592 {
16593         unsigned int present;
16594         unsigned char bits;
16595
16596         present = snd_hda_jack_detect(codec, 0x1b);
16597         bits = present ? HDA_AMP_MUTE : 0;
16598
16599         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16600                                  HDA_AMP_MUTE, bits);
16601         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16602                                  HDA_AMP_MUTE, bits);
16603 }
16604
16605 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16606                                            unsigned int res)
16607 {
16608         if ((res >> 26) == ALC880_HP_EVENT)
16609                 alc662_lenovo_101e_all_automute(codec);
16610         if ((res >> 26) == ALC880_FRONT_EVENT)
16611                 alc662_lenovo_101e_ispeaker_automute(codec);
16612 }
16613
16614 /* unsolicited event for HP jack sensing */
16615 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16616                                      unsigned int res)
16617 {
16618         if ((res >> 26) == ALC880_MIC_EVENT)
16619                 alc_mic_automute(codec);
16620         else
16621                 alc262_hippo_unsol_event(codec, res);
16622 }
16623
16624 static void alc662_eeepc_setup(struct hda_codec *codec)
16625 {
16626         struct alc_spec *spec = codec->spec;
16627
16628         alc262_hippo1_setup(codec);
16629         spec->ext_mic.pin = 0x18;
16630         spec->ext_mic.mux_idx = 0;
16631         spec->int_mic.pin = 0x19;
16632         spec->int_mic.mux_idx = 1;
16633         spec->auto_mic = 1;
16634 }
16635
16636 static void alc662_eeepc_inithook(struct hda_codec *codec)
16637 {
16638         alc262_hippo_automute(codec);
16639         alc_mic_automute(codec);
16640 }
16641
16642 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16643 {
16644         struct alc_spec *spec = codec->spec;
16645
16646         spec->autocfg.hp_pins[0] = 0x14;
16647         spec->autocfg.speaker_pins[0] = 0x1b;
16648 }
16649
16650 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
16651
16652 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16653 {
16654         unsigned int present;
16655         unsigned char bits;
16656
16657         present = snd_hda_jack_detect(codec, 0x21);
16658         bits = present ? HDA_AMP_MUTE : 0;
16659         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16660                                 AMP_IN_MUTE(0), bits);
16661         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16662                                 AMP_IN_MUTE(0), bits);
16663 }
16664
16665 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16666 {
16667         unsigned int present;
16668         unsigned char bits;
16669
16670         present = snd_hda_jack_detect(codec, 0x21);
16671         bits = present ? HDA_AMP_MUTE : 0;
16672         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16673                                 AMP_IN_MUTE(0), bits);
16674         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16675                                 AMP_IN_MUTE(0), bits);
16676         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16677                                 AMP_IN_MUTE(0), bits);
16678         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16679                                 AMP_IN_MUTE(0), bits);
16680 }
16681
16682 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16683 {
16684         unsigned int present;
16685         unsigned char bits;
16686
16687         present = snd_hda_jack_detect(codec, 0x15);
16688         bits = present ? HDA_AMP_MUTE : 0;
16689         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16690                                 AMP_IN_MUTE(0), bits);
16691         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16692                                 AMP_IN_MUTE(0), bits);
16693         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16694                                 AMP_IN_MUTE(0), bits);
16695         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16696                                 AMP_IN_MUTE(0), bits);
16697 }
16698
16699 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16700 {
16701         unsigned int present;
16702         unsigned char bits;
16703
16704         present = snd_hda_jack_detect(codec, 0x1b);
16705         bits = present ? 0 : PIN_OUT;
16706         snd_hda_codec_write(codec, 0x14, 0,
16707                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16708 }
16709
16710 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16711 {
16712         unsigned int present1, present2;
16713
16714         present1 = snd_hda_jack_detect(codec, 0x21);
16715         present2 = snd_hda_jack_detect(codec, 0x15);
16716
16717         if (present1 || present2) {
16718                 snd_hda_codec_write_cache(codec, 0x14, 0,
16719                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16720         } else {
16721                 snd_hda_codec_write_cache(codec, 0x14, 0,
16722                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16723         }
16724 }
16725
16726 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16727 {
16728         unsigned int present1, present2;
16729
16730         present1 = snd_hda_jack_detect(codec, 0x1b);
16731         present2 = snd_hda_jack_detect(codec, 0x15);
16732
16733         if (present1 || present2) {
16734                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16735                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16736                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16737                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16738         } else {
16739                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16740                                 AMP_IN_MUTE(0), 0);
16741                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16742                                 AMP_IN_MUTE(0), 0);
16743         }
16744 }
16745
16746 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16747                                            unsigned int res)
16748 {
16749         switch (res >> 26) {
16750         case ALC880_HP_EVENT:
16751                 alc663_m51va_speaker_automute(codec);
16752                 break;
16753         case ALC880_MIC_EVENT:
16754                 alc_mic_automute(codec);
16755                 break;
16756         }
16757 }
16758
16759 static void alc663_m51va_setup(struct hda_codec *codec)
16760 {
16761         struct alc_spec *spec = codec->spec;
16762         spec->ext_mic.pin = 0x18;
16763         spec->ext_mic.mux_idx = 0;
16764         spec->int_mic.pin = 0x12;
16765         spec->int_mic.mux_idx = 1;
16766         spec->auto_mic = 1;
16767 }
16768
16769 static void alc663_m51va_inithook(struct hda_codec *codec)
16770 {
16771         alc663_m51va_speaker_automute(codec);
16772         alc_mic_automute(codec);
16773 }
16774
16775 /* ***************** Mode1 ******************************/
16776 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
16777 #define alc663_mode1_setup              alc663_m51va_setup
16778 #define alc663_mode1_inithook           alc663_m51va_inithook
16779
16780 /* ***************** Mode2 ******************************/
16781 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16782                                            unsigned int res)
16783 {
16784         switch (res >> 26) {
16785         case ALC880_HP_EVENT:
16786                 alc662_f5z_speaker_automute(codec);
16787                 break;
16788         case ALC880_MIC_EVENT:
16789                 alc_mic_automute(codec);
16790                 break;
16791         }
16792 }
16793
16794 #define alc662_mode2_setup      alc663_m51va_setup
16795
16796 static void alc662_mode2_inithook(struct hda_codec *codec)
16797 {
16798         alc662_f5z_speaker_automute(codec);
16799         alc_mic_automute(codec);
16800 }
16801 /* ***************** Mode3 ******************************/
16802 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16803                                            unsigned int res)
16804 {
16805         switch (res >> 26) {
16806         case ALC880_HP_EVENT:
16807                 alc663_two_hp_m1_speaker_automute(codec);
16808                 break;
16809         case ALC880_MIC_EVENT:
16810                 alc_mic_automute(codec);
16811                 break;
16812         }
16813 }
16814
16815 #define alc663_mode3_setup      alc663_m51va_setup
16816
16817 static void alc663_mode3_inithook(struct hda_codec *codec)
16818 {
16819         alc663_two_hp_m1_speaker_automute(codec);
16820         alc_mic_automute(codec);
16821 }
16822 /* ***************** Mode4 ******************************/
16823 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16824                                            unsigned int res)
16825 {
16826         switch (res >> 26) {
16827         case ALC880_HP_EVENT:
16828                 alc663_21jd_two_speaker_automute(codec);
16829                 break;
16830         case ALC880_MIC_EVENT:
16831                 alc_mic_automute(codec);
16832                 break;
16833         }
16834 }
16835
16836 #define alc663_mode4_setup      alc663_m51va_setup
16837
16838 static void alc663_mode4_inithook(struct hda_codec *codec)
16839 {
16840         alc663_21jd_two_speaker_automute(codec);
16841         alc_mic_automute(codec);
16842 }
16843 /* ***************** Mode5 ******************************/
16844 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16845                                            unsigned int res)
16846 {
16847         switch (res >> 26) {
16848         case ALC880_HP_EVENT:
16849                 alc663_15jd_two_speaker_automute(codec);
16850                 break;
16851         case ALC880_MIC_EVENT:
16852                 alc_mic_automute(codec);
16853                 break;
16854         }
16855 }
16856
16857 #define alc663_mode5_setup      alc663_m51va_setup
16858
16859 static void alc663_mode5_inithook(struct hda_codec *codec)
16860 {
16861         alc663_15jd_two_speaker_automute(codec);
16862         alc_mic_automute(codec);
16863 }
16864 /* ***************** Mode6 ******************************/
16865 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16866                                            unsigned int res)
16867 {
16868         switch (res >> 26) {
16869         case ALC880_HP_EVENT:
16870                 alc663_two_hp_m2_speaker_automute(codec);
16871                 break;
16872         case ALC880_MIC_EVENT:
16873                 alc_mic_automute(codec);
16874                 break;
16875         }
16876 }
16877
16878 #define alc663_mode6_setup      alc663_m51va_setup
16879
16880 static void alc663_mode6_inithook(struct hda_codec *codec)
16881 {
16882         alc663_two_hp_m2_speaker_automute(codec);
16883         alc_mic_automute(codec);
16884 }
16885
16886 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16887 {
16888         unsigned int present;
16889         unsigned char bits;
16890
16891         present = snd_hda_jack_detect(codec, 0x21);
16892         bits = present ? HDA_AMP_MUTE : 0;
16893         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16894                                  HDA_AMP_MUTE, bits);
16895         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16896                                  HDA_AMP_MUTE, bits);
16897 }
16898
16899 static void alc663_g71v_front_automute(struct hda_codec *codec)
16900 {
16901         unsigned int present;
16902         unsigned char bits;
16903
16904         present = snd_hda_jack_detect(codec, 0x15);
16905         bits = present ? HDA_AMP_MUTE : 0;
16906         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16907                                  HDA_AMP_MUTE, bits);
16908 }
16909
16910 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16911                                            unsigned int res)
16912 {
16913         switch (res >> 26) {
16914         case ALC880_HP_EVENT:
16915                 alc663_g71v_hp_automute(codec);
16916                 break;
16917         case ALC880_FRONT_EVENT:
16918                 alc663_g71v_front_automute(codec);
16919                 break;
16920         case ALC880_MIC_EVENT:
16921                 alc_mic_automute(codec);
16922                 break;
16923         }
16924 }
16925
16926 #define alc663_g71v_setup       alc663_m51va_setup
16927
16928 static void alc663_g71v_inithook(struct hda_codec *codec)
16929 {
16930         alc663_g71v_front_automute(codec);
16931         alc663_g71v_hp_automute(codec);
16932         alc_mic_automute(codec);
16933 }
16934
16935 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16936                                            unsigned int res)
16937 {
16938         switch (res >> 26) {
16939         case ALC880_HP_EVENT:
16940                 alc663_m51va_speaker_automute(codec);
16941                 break;
16942         case ALC880_MIC_EVENT:
16943                 alc_mic_automute(codec);
16944                 break;
16945         }
16946 }
16947
16948 #define alc663_g50v_setup       alc663_m51va_setup
16949
16950 static void alc663_g50v_inithook(struct hda_codec *codec)
16951 {
16952         alc663_m51va_speaker_automute(codec);
16953         alc_mic_automute(codec);
16954 }
16955
16956 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16957         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16958         ALC262_HIPPO_MASTER_SWITCH,
16959
16960         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16961         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16962         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16963
16964         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16965         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16966         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16967         { } /* end */
16968 };
16969
16970 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16971         /* Master Playback automatically created from Speaker and Headphone */
16972         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16973         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16974         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16975         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16976
16977         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16978         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16979         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16980
16981         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16982         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16983         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16984         { } /* end */
16985 };
16986
16987 #ifdef CONFIG_SND_HDA_POWER_SAVE
16988 #define alc662_loopbacks        alc880_loopbacks
16989 #endif
16990
16991
16992 /* pcm configuration: identical with ALC880 */
16993 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16994 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16995 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16996 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16997
16998 /*
16999  * configuration and preset
17000  */
17001 static const char *alc662_models[ALC662_MODEL_LAST] = {
17002         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17003         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17004         [ALC662_3ST_6ch]        = "3stack-6ch",
17005         [ALC662_5ST_DIG]        = "6stack-dig",
17006         [ALC662_LENOVO_101E]    = "lenovo-101e",
17007         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17008         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17009         [ALC662_ECS] = "ecs",
17010         [ALC663_ASUS_M51VA] = "m51va",
17011         [ALC663_ASUS_G71V] = "g71v",
17012         [ALC663_ASUS_H13] = "h13",
17013         [ALC663_ASUS_G50V] = "g50v",
17014         [ALC663_ASUS_MODE1] = "asus-mode1",
17015         [ALC662_ASUS_MODE2] = "asus-mode2",
17016         [ALC663_ASUS_MODE3] = "asus-mode3",
17017         [ALC663_ASUS_MODE4] = "asus-mode4",
17018         [ALC663_ASUS_MODE5] = "asus-mode5",
17019         [ALC663_ASUS_MODE6] = "asus-mode6",
17020         [ALC272_DELL]           = "dell",
17021         [ALC272_DELL_ZM1]       = "dell-zm1",
17022         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17023         [ALC662_AUTO]           = "auto",
17024 };
17025
17026 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17027         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17028         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17029         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17030         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17031         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17032         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17033         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17034         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17035         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17036         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17037         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17038         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17039         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17040         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17041         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17042         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17043         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17044         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17045         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17046         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17047         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17048         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17049         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17050         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17051         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17052         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17053         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17054         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17055         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17056         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17057         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17058         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17059         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17060         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17061         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17062         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17063         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17064         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17065         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17066         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17067         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17068         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17069         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17070         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17071         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17072         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17073         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17074         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17075         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17076         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17077         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17078         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17079                       ALC662_3ST_6ch_DIG),
17080         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
17081         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17082         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17083                       ALC662_3ST_6ch_DIG),
17084         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17085         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17086         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17087         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17088                                         ALC662_3ST_6ch_DIG),
17089         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17090                            ALC663_ASUS_H13),
17091         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17092         {}
17093 };
17094
17095 static struct alc_config_preset alc662_presets[] = {
17096         [ALC662_3ST_2ch_DIG] = {
17097                 .mixers = { alc662_3ST_2ch_mixer },
17098                 .init_verbs = { alc662_init_verbs },
17099                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17100                 .dac_nids = alc662_dac_nids,
17101                 .dig_out_nid = ALC662_DIGOUT_NID,
17102                 .dig_in_nid = ALC662_DIGIN_NID,
17103                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17104                 .channel_mode = alc662_3ST_2ch_modes,
17105                 .input_mux = &alc662_capture_source,
17106         },
17107         [ALC662_3ST_6ch_DIG] = {
17108                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17109                 .init_verbs = { alc662_init_verbs },
17110                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17111                 .dac_nids = alc662_dac_nids,
17112                 .dig_out_nid = ALC662_DIGOUT_NID,
17113                 .dig_in_nid = ALC662_DIGIN_NID,
17114                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17115                 .channel_mode = alc662_3ST_6ch_modes,
17116                 .need_dac_fix = 1,
17117                 .input_mux = &alc662_capture_source,
17118         },
17119         [ALC662_3ST_6ch] = {
17120                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17121                 .init_verbs = { alc662_init_verbs },
17122                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17123                 .dac_nids = alc662_dac_nids,
17124                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17125                 .channel_mode = alc662_3ST_6ch_modes,
17126                 .need_dac_fix = 1,
17127                 .input_mux = &alc662_capture_source,
17128         },
17129         [ALC662_5ST_DIG] = {
17130                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17131                 .init_verbs = { alc662_init_verbs },
17132                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17133                 .dac_nids = alc662_dac_nids,
17134                 .dig_out_nid = ALC662_DIGOUT_NID,
17135                 .dig_in_nid = ALC662_DIGIN_NID,
17136                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17137                 .channel_mode = alc662_5stack_modes,
17138                 .input_mux = &alc662_capture_source,
17139         },
17140         [ALC662_LENOVO_101E] = {
17141                 .mixers = { alc662_lenovo_101e_mixer },
17142                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17143                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17144                 .dac_nids = alc662_dac_nids,
17145                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17146                 .channel_mode = alc662_3ST_2ch_modes,
17147                 .input_mux = &alc662_lenovo_101e_capture_source,
17148                 .unsol_event = alc662_lenovo_101e_unsol_event,
17149                 .init_hook = alc662_lenovo_101e_all_automute,
17150         },
17151         [ALC662_ASUS_EEEPC_P701] = {
17152                 .mixers = { alc662_eeepc_p701_mixer },
17153                 .init_verbs = { alc662_init_verbs,
17154                                 alc662_eeepc_sue_init_verbs },
17155                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17156                 .dac_nids = alc662_dac_nids,
17157                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17158                 .channel_mode = alc662_3ST_2ch_modes,
17159                 .unsol_event = alc662_eeepc_unsol_event,
17160                 .setup = alc662_eeepc_setup,
17161                 .init_hook = alc662_eeepc_inithook,
17162         },
17163         [ALC662_ASUS_EEEPC_EP20] = {
17164                 .mixers = { alc662_eeepc_ep20_mixer,
17165                             alc662_chmode_mixer },
17166                 .init_verbs = { alc662_init_verbs,
17167                                 alc662_eeepc_ep20_sue_init_verbs },
17168                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17169                 .dac_nids = alc662_dac_nids,
17170                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17171                 .channel_mode = alc662_3ST_6ch_modes,
17172                 .input_mux = &alc662_lenovo_101e_capture_source,
17173                 .unsol_event = alc662_eeepc_unsol_event,
17174                 .setup = alc662_eeepc_ep20_setup,
17175                 .init_hook = alc662_eeepc_ep20_inithook,
17176         },
17177         [ALC662_ECS] = {
17178                 .mixers = { alc662_ecs_mixer },
17179                 .init_verbs = { alc662_init_verbs,
17180                                 alc662_ecs_init_verbs },
17181                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17182                 .dac_nids = alc662_dac_nids,
17183                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17184                 .channel_mode = alc662_3ST_2ch_modes,
17185                 .unsol_event = alc662_eeepc_unsol_event,
17186                 .setup = alc662_eeepc_setup,
17187                 .init_hook = alc662_eeepc_inithook,
17188         },
17189         [ALC663_ASUS_M51VA] = {
17190                 .mixers = { alc663_m51va_mixer },
17191                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17192                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17193                 .dac_nids = alc662_dac_nids,
17194                 .dig_out_nid = ALC662_DIGOUT_NID,
17195                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17196                 .channel_mode = alc662_3ST_2ch_modes,
17197                 .unsol_event = alc663_m51va_unsol_event,
17198                 .setup = alc663_m51va_setup,
17199                 .init_hook = alc663_m51va_inithook,
17200         },
17201         [ALC663_ASUS_G71V] = {
17202                 .mixers = { alc663_g71v_mixer },
17203                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17204                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17205                 .dac_nids = alc662_dac_nids,
17206                 .dig_out_nid = ALC662_DIGOUT_NID,
17207                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17208                 .channel_mode = alc662_3ST_2ch_modes,
17209                 .unsol_event = alc663_g71v_unsol_event,
17210                 .setup = alc663_g71v_setup,
17211                 .init_hook = alc663_g71v_inithook,
17212         },
17213         [ALC663_ASUS_H13] = {
17214                 .mixers = { alc663_m51va_mixer },
17215                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17216                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17217                 .dac_nids = alc662_dac_nids,
17218                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17219                 .channel_mode = alc662_3ST_2ch_modes,
17220                 .unsol_event = alc663_m51va_unsol_event,
17221                 .init_hook = alc663_m51va_inithook,
17222         },
17223         [ALC663_ASUS_G50V] = {
17224                 .mixers = { alc663_g50v_mixer },
17225                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17226                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17227                 .dac_nids = alc662_dac_nids,
17228                 .dig_out_nid = ALC662_DIGOUT_NID,
17229                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17230                 .channel_mode = alc662_3ST_6ch_modes,
17231                 .input_mux = &alc663_capture_source,
17232                 .unsol_event = alc663_g50v_unsol_event,
17233                 .setup = alc663_g50v_setup,
17234                 .init_hook = alc663_g50v_inithook,
17235         },
17236         [ALC663_ASUS_MODE1] = {
17237                 .mixers = { alc663_m51va_mixer },
17238                 .cap_mixer = alc662_auto_capture_mixer,
17239                 .init_verbs = { alc662_init_verbs,
17240                                 alc663_21jd_amic_init_verbs },
17241                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17242                 .hp_nid = 0x03,
17243                 .dac_nids = alc662_dac_nids,
17244                 .dig_out_nid = ALC662_DIGOUT_NID,
17245                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17246                 .channel_mode = alc662_3ST_2ch_modes,
17247                 .unsol_event = alc663_mode1_unsol_event,
17248                 .setup = alc663_mode1_setup,
17249                 .init_hook = alc663_mode1_inithook,
17250         },
17251         [ALC662_ASUS_MODE2] = {
17252                 .mixers = { alc662_1bjd_mixer },
17253                 .cap_mixer = alc662_auto_capture_mixer,
17254                 .init_verbs = { alc662_init_verbs,
17255                                 alc662_1bjd_amic_init_verbs },
17256                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17257                 .dac_nids = alc662_dac_nids,
17258                 .dig_out_nid = ALC662_DIGOUT_NID,
17259                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17260                 .channel_mode = alc662_3ST_2ch_modes,
17261                 .unsol_event = alc662_mode2_unsol_event,
17262                 .setup = alc662_mode2_setup,
17263                 .init_hook = alc662_mode2_inithook,
17264         },
17265         [ALC663_ASUS_MODE3] = {
17266                 .mixers = { alc663_two_hp_m1_mixer },
17267                 .cap_mixer = alc662_auto_capture_mixer,
17268                 .init_verbs = { alc662_init_verbs,
17269                                 alc663_two_hp_amic_m1_init_verbs },
17270                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17271                 .hp_nid = 0x03,
17272                 .dac_nids = alc662_dac_nids,
17273                 .dig_out_nid = ALC662_DIGOUT_NID,
17274                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17275                 .channel_mode = alc662_3ST_2ch_modes,
17276                 .unsol_event = alc663_mode3_unsol_event,
17277                 .setup = alc663_mode3_setup,
17278                 .init_hook = alc663_mode3_inithook,
17279         },
17280         [ALC663_ASUS_MODE4] = {
17281                 .mixers = { alc663_asus_21jd_clfe_mixer },
17282                 .cap_mixer = alc662_auto_capture_mixer,
17283                 .init_verbs = { alc662_init_verbs,
17284                                 alc663_21jd_amic_init_verbs},
17285                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17286                 .hp_nid = 0x03,
17287                 .dac_nids = alc662_dac_nids,
17288                 .dig_out_nid = ALC662_DIGOUT_NID,
17289                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17290                 .channel_mode = alc662_3ST_2ch_modes,
17291                 .unsol_event = alc663_mode4_unsol_event,
17292                 .setup = alc663_mode4_setup,
17293                 .init_hook = alc663_mode4_inithook,
17294         },
17295         [ALC663_ASUS_MODE5] = {
17296                 .mixers = { alc663_asus_15jd_clfe_mixer },
17297                 .cap_mixer = alc662_auto_capture_mixer,
17298                 .init_verbs = { alc662_init_verbs,
17299                                 alc663_15jd_amic_init_verbs },
17300                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17301                 .hp_nid = 0x03,
17302                 .dac_nids = alc662_dac_nids,
17303                 .dig_out_nid = ALC662_DIGOUT_NID,
17304                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17305                 .channel_mode = alc662_3ST_2ch_modes,
17306                 .unsol_event = alc663_mode5_unsol_event,
17307                 .setup = alc663_mode5_setup,
17308                 .init_hook = alc663_mode5_inithook,
17309         },
17310         [ALC663_ASUS_MODE6] = {
17311                 .mixers = { alc663_two_hp_m2_mixer },
17312                 .cap_mixer = alc662_auto_capture_mixer,
17313                 .init_verbs = { alc662_init_verbs,
17314                                 alc663_two_hp_amic_m2_init_verbs },
17315                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17316                 .hp_nid = 0x03,
17317                 .dac_nids = alc662_dac_nids,
17318                 .dig_out_nid = ALC662_DIGOUT_NID,
17319                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17320                 .channel_mode = alc662_3ST_2ch_modes,
17321                 .unsol_event = alc663_mode6_unsol_event,
17322                 .setup = alc663_mode6_setup,
17323                 .init_hook = alc663_mode6_inithook,
17324         },
17325         [ALC272_DELL] = {
17326                 .mixers = { alc663_m51va_mixer },
17327                 .cap_mixer = alc272_auto_capture_mixer,
17328                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17329                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17330                 .dac_nids = alc662_dac_nids,
17331                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17332                 .adc_nids = alc272_adc_nids,
17333                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17334                 .capsrc_nids = alc272_capsrc_nids,
17335                 .channel_mode = alc662_3ST_2ch_modes,
17336                 .unsol_event = alc663_m51va_unsol_event,
17337                 .setup = alc663_m51va_setup,
17338                 .init_hook = alc663_m51va_inithook,
17339         },
17340         [ALC272_DELL_ZM1] = {
17341                 .mixers = { alc663_m51va_mixer },
17342                 .cap_mixer = alc662_auto_capture_mixer,
17343                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17344                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17345                 .dac_nids = alc662_dac_nids,
17346                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17347                 .adc_nids = alc662_adc_nids,
17348                 .num_adc_nids = 1,
17349                 .capsrc_nids = alc662_capsrc_nids,
17350                 .channel_mode = alc662_3ST_2ch_modes,
17351                 .unsol_event = alc663_m51va_unsol_event,
17352                 .setup = alc663_m51va_setup,
17353                 .init_hook = alc663_m51va_inithook,
17354         },
17355         [ALC272_SAMSUNG_NC10] = {
17356                 .mixers = { alc272_nc10_mixer },
17357                 .init_verbs = { alc662_init_verbs,
17358                                 alc663_21jd_amic_init_verbs },
17359                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17360                 .dac_nids = alc272_dac_nids,
17361                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17362                 .channel_mode = alc662_3ST_2ch_modes,
17363                 /*.input_mux = &alc272_nc10_capture_source,*/
17364                 .unsol_event = alc663_mode4_unsol_event,
17365                 .setup = alc663_mode4_setup,
17366                 .init_hook = alc663_mode4_inithook,
17367         },
17368 };
17369
17370
17371 /*
17372  * BIOS auto configuration
17373  */
17374
17375 /* convert from MIX nid to DAC */
17376 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17377 {
17378         if (nid == 0x0f)
17379                 return 0x02;
17380         else if (nid >= 0x0c && nid <= 0x0e)
17381                 return nid - 0x0c + 0x02;
17382         else
17383                 return 0;
17384 }
17385
17386 /* get MIX nid connected to the given pin targeted to DAC */
17387 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17388                                    hda_nid_t dac)
17389 {
17390         hda_nid_t mix[4];
17391         int i, num;
17392
17393         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17394         for (i = 0; i < num; i++) {
17395                 if (alc662_mix_to_dac(mix[i]) == dac)
17396                         return mix[i];
17397         }
17398         return 0;
17399 }
17400
17401 /* look for an empty DAC slot */
17402 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17403 {
17404         struct alc_spec *spec = codec->spec;
17405         hda_nid_t srcs[5];
17406         int i, j, num;
17407
17408         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17409         if (num < 0)
17410                 return 0;
17411         for (i = 0; i < num; i++) {
17412                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17413                 if (!nid)
17414                         continue;
17415                 for (j = 0; j < spec->multiout.num_dacs; j++)
17416                         if (spec->multiout.dac_nids[j] == nid)
17417                                 break;
17418                 if (j >= spec->multiout.num_dacs)
17419                         return nid;
17420         }
17421         return 0;
17422 }
17423
17424 /* fill in the dac_nids table from the parsed pin configuration */
17425 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17426                                      const struct auto_pin_cfg *cfg)
17427 {
17428         struct alc_spec *spec = codec->spec;
17429         int i;
17430         hda_nid_t dac;
17431
17432         spec->multiout.dac_nids = spec->private_dac_nids;
17433         for (i = 0; i < cfg->line_outs; i++) {
17434                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17435                 if (!dac)
17436                         continue;
17437                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17438         }
17439         return 0;
17440 }
17441
17442 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17443                               hda_nid_t nid, unsigned int chs)
17444 {
17445         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
17446                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17447 }
17448
17449 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17450                              hda_nid_t nid, unsigned int chs)
17451 {
17452         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17453                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17454 }
17455
17456 #define alc662_add_stereo_vol(spec, pfx, nid) \
17457         alc662_add_vol_ctl(spec, pfx, nid, 3)
17458 #define alc662_add_stereo_sw(spec, pfx, nid) \
17459         alc662_add_sw_ctl(spec, pfx, nid, 3)
17460
17461 /* add playback controls from the parsed DAC table */
17462 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17463                                              const struct auto_pin_cfg *cfg)
17464 {
17465         struct alc_spec *spec = codec->spec;
17466         static const char *chname[4] = {
17467                 "Front", "Surround", NULL /*CLFE*/, "Side"
17468         };
17469         hda_nid_t nid, mix;
17470         int i, err;
17471
17472         for (i = 0; i < cfg->line_outs; i++) {
17473                 nid = spec->multiout.dac_nids[i];
17474                 if (!nid)
17475                         continue;
17476                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17477                 if (!mix)
17478                         continue;
17479                 if (i == 2) {
17480                         /* Center/LFE */
17481                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17482                         if (err < 0)
17483                                 return err;
17484                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17485                         if (err < 0)
17486                                 return err;
17487                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17488                         if (err < 0)
17489                                 return err;
17490                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17491                         if (err < 0)
17492                                 return err;
17493                 } else {
17494                         const char *pfx;
17495                         if (cfg->line_outs == 1 &&
17496                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17497                                 if (cfg->hp_outs)
17498                                         pfx = "Speaker";
17499                                 else
17500                                         pfx = "PCM";
17501                         } else
17502                                 pfx = chname[i];
17503                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17504                         if (err < 0)
17505                                 return err;
17506                         if (cfg->line_outs == 1 &&
17507                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17508                                 pfx = "Speaker";
17509                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17510                         if (err < 0)
17511                                 return err;
17512                 }
17513         }
17514         return 0;
17515 }
17516
17517 /* add playback controls for speaker and HP outputs */
17518 /* return DAC nid if any new DAC is assigned */
17519 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17520                                         const char *pfx)
17521 {
17522         struct alc_spec *spec = codec->spec;
17523         hda_nid_t nid, mix;
17524         int err;
17525
17526         if (!pin)
17527                 return 0;
17528         nid = alc662_look_for_dac(codec, pin);
17529         if (!nid) {
17530                 /* the corresponding DAC is already occupied */
17531                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17532                         return 0; /* no way */
17533                 /* create a switch only */
17534                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
17535                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17536         }
17537
17538         mix = alc662_dac_to_mix(codec, pin, nid);
17539         if (!mix)
17540                 return 0;
17541         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17542         if (err < 0)
17543                 return err;
17544         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17545         if (err < 0)
17546                 return err;
17547         return nid;
17548 }
17549
17550 /* create playback/capture controls for input pins */
17551 #define alc662_auto_create_input_ctls \
17552         alc882_auto_create_input_ctls
17553
17554 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17555                                               hda_nid_t nid, int pin_type,
17556                                               hda_nid_t dac)
17557 {
17558         int i, num;
17559         hda_nid_t srcs[4];
17560
17561         alc_set_pin_output(codec, nid, pin_type);
17562         /* need the manual connection? */
17563         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17564         if (num <= 1)
17565                 return;
17566         for (i = 0; i < num; i++) {
17567                 if (alc662_mix_to_dac(srcs[i]) != dac)
17568                         continue;
17569                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17570                 return;
17571         }
17572 }
17573
17574 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17575 {
17576         struct alc_spec *spec = codec->spec;
17577         int pin_type = get_pin_type(spec->autocfg.line_out_type);
17578         int i;
17579
17580         for (i = 0; i <= HDA_SIDE; i++) {
17581                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17582                 if (nid)
17583                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17584                                         spec->multiout.dac_nids[i]);
17585         }
17586 }
17587
17588 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17589 {
17590         struct alc_spec *spec = codec->spec;
17591         hda_nid_t pin;
17592
17593         pin = spec->autocfg.hp_pins[0];
17594         if (pin)
17595                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17596                                                   spec->multiout.hp_nid);
17597         pin = spec->autocfg.speaker_pins[0];
17598         if (pin)
17599                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17600                                         spec->multiout.extra_out_nid[0]);
17601 }
17602
17603 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17604
17605 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17606 {
17607         struct alc_spec *spec = codec->spec;
17608         int i;
17609
17610         for (i = 0; i < AUTO_PIN_LAST; i++) {
17611                 hda_nid_t nid = spec->autocfg.input_pins[i];
17612                 if (alc_is_input_pin(codec, nid)) {
17613                         alc_set_input_pin(codec, nid, i);
17614                         if (nid != ALC662_PIN_CD_NID &&
17615                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17616                                 snd_hda_codec_write(codec, nid, 0,
17617                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17618                                                     AMP_OUT_MUTE);
17619                 }
17620         }
17621 }
17622
17623 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17624
17625 static int alc662_parse_auto_config(struct hda_codec *codec)
17626 {
17627         struct alc_spec *spec = codec->spec;
17628         int err;
17629         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17630
17631         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17632                                            alc662_ignore);
17633         if (err < 0)
17634                 return err;
17635         if (!spec->autocfg.line_outs)
17636                 return 0; /* can't find valid BIOS pin config */
17637
17638         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17639         if (err < 0)
17640                 return err;
17641         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17642         if (err < 0)
17643                 return err;
17644         err = alc662_auto_create_extra_out(codec,
17645                                            spec->autocfg.speaker_pins[0],
17646                                            "Speaker");
17647         if (err < 0)
17648                 return err;
17649         if (err)
17650                 spec->multiout.extra_out_nid[0] = err;
17651         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17652                                            "Headphone");
17653         if (err < 0)
17654                 return err;
17655         if (err)
17656                 spec->multiout.hp_nid = err;
17657         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17658         if (err < 0)
17659                 return err;
17660
17661         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17662
17663         if (spec->autocfg.dig_outs)
17664                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17665
17666         if (spec->kctls.list)
17667                 add_mixer(spec, spec->kctls.list);
17668
17669         spec->num_mux_defs = 1;
17670         spec->input_mux = &spec->private_imux[0];
17671
17672         add_verb(spec, alc662_auto_init_verbs);
17673         if (codec->vendor_id == 0x10ec0663)
17674                 add_verb(spec, alc663_auto_init_verbs);
17675
17676         err = alc_auto_add_mic_boost(codec);
17677         if (err < 0)
17678                 return err;
17679
17680         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17681
17682         return 1;
17683 }
17684
17685 /* additional initialization for auto-configuration model */
17686 static void alc662_auto_init(struct hda_codec *codec)
17687 {
17688         struct alc_spec *spec = codec->spec;
17689         alc662_auto_init_multi_out(codec);
17690         alc662_auto_init_hp_out(codec);
17691         alc662_auto_init_analog_input(codec);
17692         alc662_auto_init_input_src(codec);
17693         if (spec->unsol_event)
17694                 alc_inithook(codec);
17695 }
17696
17697 static int patch_alc662(struct hda_codec *codec)
17698 {
17699         struct alc_spec *spec;
17700         int err, board_config;
17701
17702         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17703         if (!spec)
17704                 return -ENOMEM;
17705
17706         codec->spec = spec;
17707
17708         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17709
17710         if (alc_read_coef_idx(codec, 0)==0x8020){
17711                 kfree(codec->chip_name);
17712                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
17713                 if (!codec->chip_name) {
17714                         alc_free(codec);
17715                         return -ENOMEM;
17716                 }
17717         }
17718
17719         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17720                                                   alc662_models,
17721                                                   alc662_cfg_tbl);
17722         if (board_config < 0) {
17723                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17724                        codec->chip_name);
17725                 board_config = ALC662_AUTO;
17726         }
17727
17728         if (board_config == ALC662_AUTO) {
17729                 /* automatic parse from the BIOS config */
17730                 err = alc662_parse_auto_config(codec);
17731                 if (err < 0) {
17732                         alc_free(codec);
17733                         return err;
17734                 } else if (!err) {
17735                         printk(KERN_INFO
17736                                "hda_codec: Cannot set up configuration "
17737                                "from BIOS.  Using base mode...\n");
17738                         board_config = ALC662_3ST_2ch_DIG;
17739                 }
17740         }
17741
17742         err = snd_hda_attach_beep_device(codec, 0x1);
17743         if (err < 0) {
17744                 alc_free(codec);
17745                 return err;
17746         }
17747
17748         if (board_config != ALC662_AUTO)
17749                 setup_preset(codec, &alc662_presets[board_config]);
17750
17751         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17752         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17753
17754         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17755         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17756
17757         if (!spec->adc_nids) {
17758                 spec->adc_nids = alc662_adc_nids;
17759                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17760         }
17761         if (!spec->capsrc_nids)
17762                 spec->capsrc_nids = alc662_capsrc_nids;
17763
17764         if (!spec->cap_mixer)
17765                 set_capture_mixer(codec);
17766         if (codec->vendor_id == 0x10ec0662)
17767                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17768         else
17769                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17770
17771         spec->vmaster_nid = 0x02;
17772
17773         codec->patch_ops = alc_patch_ops;
17774         if (board_config == ALC662_AUTO)
17775                 spec->init_hook = alc662_auto_init;
17776 #ifdef CONFIG_SND_HDA_POWER_SAVE
17777         if (!spec->loopback.amplist)
17778                 spec->loopback.amplist = alc662_loopbacks;
17779 #endif
17780         codec->proc_widget_hook = print_realtek_coef;
17781
17782         return 0;
17783 }
17784
17785 static int patch_alc888(struct hda_codec *codec)
17786 {
17787         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
17788                 kfree(codec->chip_name);
17789                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
17790                 if (!codec->chip_name) {
17791                         alc_free(codec);
17792                         return -ENOMEM;
17793                 }
17794                 return patch_alc662(codec);
17795         }
17796         return patch_alc882(codec);
17797 }
17798
17799 /*
17800  * patch entries
17801  */
17802 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17803         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17804         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17805         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17806         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17807         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17808         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17809         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17810           .patch = patch_alc861 },
17811         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17812         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17813         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17814         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17815           .patch = patch_alc882 },
17816         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17817           .patch = patch_alc662 },
17818         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17819         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17820         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17821         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17822         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17823           .patch = patch_alc882 },
17824         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17825           .patch = patch_alc882 },
17826         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17827         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17828         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17829           .patch = patch_alc882 },
17830         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
17831         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17832         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
17833         {} /* terminator */
17834 };
17835
17836 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17837
17838 MODULE_LICENSE("GPL");
17839 MODULE_DESCRIPTION("Realtek HD-audio codec");
17840
17841 static struct hda_codec_preset_list realtek_list = {
17842         .preset = snd_hda_preset_realtek,
17843         .owner = THIS_MODULE,
17844 };
17845
17846 static int __init patch_realtek_init(void)
17847 {
17848         return snd_hda_add_codec_preset(&realtek_list);
17849 }
17850
17851 static void __exit patch_realtek_exit(void)
17852 {
17853         snd_hda_delete_codec_preset(&realtek_list);
17854 }
17855
17856 module_init(patch_realtek_init)
17857 module_exit(patch_realtek_exit)