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         ALC883_3ST_2ch_DIG,
 212         ALC883_3ST_6ch_DIG,
 213         ALC883_3ST_6ch,
 214         ALC883_6ST_DIG,
 215         ALC883_TARGA_DIG,
 216         ALC883_TARGA_2ch_DIG,
 217         ALC883_TARGA_8ch_DIG,
 218         ALC883_ACER,
 219         ALC883_ACER_ASPIRE,
 220         ALC888_ACER_ASPIRE_4930G,
 221         ALC888_ACER_ASPIRE_6530G,
 222         ALC888_ACER_ASPIRE_8930G,
 223         ALC888_ACER_ASPIRE_7730G,
 224         ALC883_MEDION,
 225         ALC883_MEDION_MD2,
 226         ALC883_LAPTOP_EAPD,
 227         ALC883_LENOVO_101E_2ch,
 228         ALC883_LENOVO_NB0763,
 229         ALC888_LENOVO_MS7195_DIG,
 230         ALC888_LENOVO_SKY,
 231         ALC883_HAIER_W66,
 232         ALC888_3ST_HP,
 233         ALC888_6ST_DELL,
 234         ALC883_MITAC,
 235         ALC883_CLEVO_M540R,
 236         ALC883_CLEVO_M720,
 237         ALC883_FUJITSU_PI2515,
 238         ALC888_FUJITSU_XA3530,
 239         ALC883_3ST_6ch_INTEL,
 240         ALC889A_INTEL,
 241         ALC889_INTEL,
 242         ALC888_ASUS_M90V,
 243         ALC888_ASUS_EEE1601,
 244         ALC889A_MB31,
 245         ALC1200_ASUS_P5Q,
 246         ALC883_SONY_VAIO_TT,
 247         ALC882_AUTO,
 248         ALC882_MODEL_LAST,
 249 };
 250
 251 /* for GPIO Poll */
 252 #define GPIO_MASK       0x03
 253
 254 /* extra amp-initialization sequence types */
 255 enum {
 256         ALC_INIT_NONE,
 257         ALC_INIT_DEFAULT,
 258         ALC_INIT_GPIO1,
 259         ALC_INIT_GPIO2,
 260         ALC_INIT_GPIO3,
 261 };
 262
 263 struct alc_mic_route {
 264         hda_nid_t pin;
 265         unsigned char mux_idx;
 266         unsigned char amix_idx;
 267 };
 268
 269 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 270
 271 struct alc_spec {
 272         /* codec parameterization */
 273         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 274         unsigned int num_mixers;
 275         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 276         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 277
 278         const struct hda_verb *init_verbs[5];   /* initialization verbs
 279                                                  * don't forget NULL
 280                                                  * termination!
 281                                                  */
 282         unsigned int num_init_verbs;
 283
 284         char stream_name_analog[32];    /* analog PCM stream */
 285         struct hda_pcm_stream *stream_analog_playback;
 286         struct hda_pcm_stream *stream_analog_capture;
 287         struct hda_pcm_stream *stream_analog_alt_playback;
 288         struct hda_pcm_stream *stream_analog_alt_capture;
 289
 290         char stream_name_digital[32];   /* digital PCM stream */
 291         struct hda_pcm_stream *stream_digital_playback;
 292         struct hda_pcm_stream *stream_digital_capture;
 293
 294         /* playback */
 295         struct hda_multi_out multiout;  /* playback set-up
 296                                          * max_channels, dacs must be set
 297                                          * dig_out_nid and hp_nid are optional
 298                                          */
 299         hda_nid_t alt_dac_nid;
 300         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 301         int dig_out_type;
 302
 303         /* capture */
 304         unsigned int num_adc_nids;
 305         hda_nid_t *adc_nids;
 306         hda_nid_t *capsrc_nids;
 307         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 308
 309         /* capture source */
 310         unsigned int num_mux_defs;
 311         const struct hda_input_mux *input_mux;
 312         unsigned int cur_mux[3];
 313         struct alc_mic_route ext_mic;
 314         struct alc_mic_route int_mic;
 315
 316         /* channel model */
 317         const struct hda_channel_mode *channel_mode;
 318         int num_channel_mode;
 319         int need_dac_fix;
 320         int const_channel_count;
 321         int ext_channel_count;
 322
 323         /* PCM information */
 324         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 325
 326         /* dynamic controls, init_verbs and input_mux */
 327         struct auto_pin_cfg autocfg;
 328         struct snd_array kctls;
 329         struct hda_input_mux private_imux[3];
 330         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 331         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 332         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 333
 334         /* hooks */
 335         void (*init_hook)(struct hda_codec *codec);
 336         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 337
 338         /* for pin sensing */
 339         unsigned int sense_updated: 1;
 340         unsigned int jack_present: 1;
 341         unsigned int master_sw: 1;
 342         unsigned int auto_mic:1;
 343
 344         /* other flags */
 345         unsigned int no_analog :1; /* digital I/O only */
 346         int init_amp;
 347
 348         /* for virtual master */
 349         hda_nid_t vmaster_nid;
 350 #ifdef CONFIG_SND_HDA_POWER_SAVE
 351         struct hda_loopback_check loopback;
 352 #endif
 353
 354         /* for PLL fix */
 355         hda_nid_t pll_nid;
 356         unsigned int pll_coef_idx, pll_coef_bit;
 357 };
 358
 359 /*
 360  * configuration template - to be copied to the spec instance
 361  */
 362 struct alc_config_preset {
 363         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 364                                              * with spec
 365                                              */
 366         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 367         const struct hda_verb *init_verbs[5];
 368         unsigned int num_dacs;
 369         hda_nid_t *dac_nids;
 370         hda_nid_t dig_out_nid;          /* optional */
 371         hda_nid_t hp_nid;               /* optional */
 372         hda_nid_t *slave_dig_outs;
 373         unsigned int num_adc_nids;
 374         hda_nid_t *adc_nids;
 375         hda_nid_t *capsrc_nids;
 376         hda_nid_t dig_in_nid;
 377         unsigned int num_channel_mode;
 378         const struct hda_channel_mode *channel_mode;
 379         int need_dac_fix;
 380         int const_channel_count;
 381         unsigned int num_mux_defs;
 382         const struct hda_input_mux *input_mux;
 383         void (*unsol_event)(struct hda_codec *, unsigned int);
 384         void (*setup)(struct hda_codec *);
 385         void (*init_hook)(struct hda_codec *);
 386 #ifdef CONFIG_SND_HDA_POWER_SAVE
 387         struct hda_amp_list *loopbacks;
 388 #endif
 389 };
 390
 391
 392 /*
 393  * input MUX handling
 394  */
 395 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 396                              struct snd_ctl_elem_info *uinfo)
 397 {
 398         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 399         struct alc_spec *spec = codec->spec;
 400         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 401         if (mux_idx >= spec->num_mux_defs)
 402                 mux_idx = 0;
 403         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 404 }
 405
 406 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 407                             struct snd_ctl_elem_value *ucontrol)
 408 {
 409         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 410         struct alc_spec *spec = codec->spec;
 411         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 412
 413         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 414         return 0;
 415 }
 416
 417 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 418                             struct snd_ctl_elem_value *ucontrol)
 419 {
 420         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 421         struct alc_spec *spec = codec->spec;
 422         const struct hda_input_mux *imux;
 423         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 424         unsigned int mux_idx;
 425         hda_nid_t nid = spec->capsrc_nids ?
 426                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 427         unsigned int type;
 428
 429         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 430         imux = &spec->input_mux[mux_idx];
 431
 432         type = get_wcaps_type(get_wcaps(codec, nid));
 433         if (type == AC_WID_AUD_MIX) {
 434                 /* Matrix-mixer style (e.g. ALC882) */
 435                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 436                 unsigned int i, idx;
 437
 438                 idx = ucontrol->value.enumerated.item[0];
 439                 if (idx >= imux->num_items)
 440                         idx = imux->num_items - 1;
 441                 if (*cur_val == idx)
 442                         return 0;
 443                 for (i = 0; i < imux->num_items; i++) {
 444                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 445                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 446                                                  imux->items[i].index,
 447                                                  HDA_AMP_MUTE, v);
 448                 }
 449                 *cur_val = idx;
 450                 return 1;
 451         } else {
 452                 /* MUX style (e.g. ALC880) */
 453                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 454                                              &spec->cur_mux[adc_idx]);
 455         }
 456 }
 457
 458 /*
 459  * channel mode setting
 460  */
 461 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 462                             struct snd_ctl_elem_info *uinfo)
 463 {
 464         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 465         struct alc_spec *spec = codec->spec;
 466         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 467                                     spec->num_channel_mode);
 468 }
 469
 470 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 471                            struct snd_ctl_elem_value *ucontrol)
 472 {
 473         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 474         struct alc_spec *spec = codec->spec;
 475         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 476                                    spec->num_channel_mode,
 477                                    spec->ext_channel_count);
 478 }
 479
 480 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 481                            struct snd_ctl_elem_value *ucontrol)
 482 {
 483         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 484         struct alc_spec *spec = codec->spec;
 485         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 486                                       spec->num_channel_mode,
 487                                       &spec->ext_channel_count);
 488         if (err >= 0 && !spec->const_channel_count) {
 489                 spec->multiout.max_channels = spec->ext_channel_count;
 490                 if (spec->need_dac_fix)
 491                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 492         }
 493         return err;
 494 }
 495
 496 /*
 497  * Control the mode of pin widget settings via the mixer.  "pc" is used
 498  * instead of "%" to avoid consequences of accidently treating the % as
 499  * being part of a format specifier.  Maximum allowed length of a value is
 500  * 63 characters plus NULL terminator.
 501  *
 502  * Note: some retasking pin complexes seem to ignore requests for input
 503  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 504  * are requested.  Therefore order this list so that this behaviour will not
 505  * cause problems when mixer clients move through the enum sequentially.
 506  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 507  * March 2006.
 508  */
 509 static char *alc_pin_mode_names[] = {
 510         "Mic 50pc bias", "Mic 80pc bias",
 511         "Line in", "Line out", "Headphone out",
 512 };
 513 static unsigned char alc_pin_mode_values[] = {
 514         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 515 };
 516 /* The control can present all 5 options, or it can limit the options based
 517  * in the pin being assumed to be exclusively an input or an output pin.  In
 518  * addition, "input" pins may or may not process the mic bias option
 519  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 520  * accept requests for bias as of chip versions up to March 2006) and/or
 521  * wiring in the computer.
 522  */
 523 #define ALC_PIN_DIR_IN              0x00
 524 #define ALC_PIN_DIR_OUT             0x01
 525 #define ALC_PIN_DIR_INOUT           0x02
 526 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 527 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 528
 529 /* Info about the pin modes supported by the different pin direction modes.
 530  * For each direction the minimum and maximum values are given.
 531  */
 532 static signed char alc_pin_mode_dir_info[5][2] = {
 533         { 0, 2 },    /* ALC_PIN_DIR_IN */
 534         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 535         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 536         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 537         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 538 };
 539 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 540 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 541 #define alc_pin_mode_n_items(_dir) \
 542         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 543
 544 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 545                              struct snd_ctl_elem_info *uinfo)
 546 {
 547         unsigned int item_num = uinfo->value.enumerated.item;
 548         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 549
 550         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 551         uinfo->count = 1;
 552         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 553
 554         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 555                 item_num = alc_pin_mode_min(dir);
 556         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 557         return 0;
 558 }
 559
 560 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 561                             struct snd_ctl_elem_value *ucontrol)
 562 {
 563         unsigned int i;
 564         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 565         hda_nid_t nid = kcontrol->private_value & 0xffff;
 566         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 567         long *valp = ucontrol->value.integer.value;
 568         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 569                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 570                                                  0x00);
 571
 572         /* Find enumerated value for current pinctl setting */
 573         i = alc_pin_mode_min(dir);
 574         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 575                 i++;
 576         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 577         return 0;
 578 }
 579
 580 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 581                             struct snd_ctl_elem_value *ucontrol)
 582 {
 583         signed int change;
 584         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 585         hda_nid_t nid = kcontrol->private_value & 0xffff;
 586         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 587         long val = *ucontrol->value.integer.value;
 588         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 589                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 590                                                  0x00);
 591
 592         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 593                 val = alc_pin_mode_min(dir);
 594
 595         change = pinctl != alc_pin_mode_values[val];
 596         if (change) {
 597                 /* Set pin mode to that requested */
 598                 snd_hda_codec_write_cache(codec, nid, 0,
 599                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 600                                           alc_pin_mode_values[val]);
 601
 602                 /* Also enable the retasking pin's input/output as required
 603                  * for the requested pin mode.  Enum values of 2 or less are
 604                  * input modes.
 605                  *
 606                  * Dynamically switching the input/output buffers probably
 607                  * reduces noise slightly (particularly on input) so we'll
 608                  * do it.  However, having both input and output buffers
 609                  * enabled simultaneously doesn't seem to be problematic if
 610                  * this turns out to be necessary in the future.
 611                  */
 612                 if (val <= 2) {
 613                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 614                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 615                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 616                                                  HDA_AMP_MUTE, 0);
 617                 } else {
 618                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 619                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 620                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 621                                                  HDA_AMP_MUTE, 0);
 622                 }
 623         }
 624         return change;
 625 }
 626
 627 #define ALC_PIN_MODE(xname, nid, dir) \
 628         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 629           .info = alc_pin_mode_info, \
 630           .get = alc_pin_mode_get, \
 631           .put = alc_pin_mode_put, \
 632           .private_value = nid | (dir<<16) }
 633
 634 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 635  * together using a mask with more than one bit set.  This control is
 636  * currently used only by the ALC260 test model.  At this stage they are not
 637  * needed for any "production" models.
 638  */
 639 #ifdef CONFIG_SND_DEBUG
 640 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 641
 642 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 643                              struct snd_ctl_elem_value *ucontrol)
 644 {
 645         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 646         hda_nid_t nid = kcontrol->private_value & 0xffff;
 647         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 648         long *valp = ucontrol->value.integer.value;
 649         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 650                                               AC_VERB_GET_GPIO_DATA, 0x00);
 651
 652         *valp = (val & mask) != 0;
 653         return 0;
 654 }
 655 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 656                              struct snd_ctl_elem_value *ucontrol)
 657 {
 658         signed int change;
 659         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 660         hda_nid_t nid = kcontrol->private_value & 0xffff;
 661         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 662         long val = *ucontrol->value.integer.value;
 663         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 664                                                     AC_VERB_GET_GPIO_DATA,
 665                                                     0x00);
 666
 667         /* Set/unset the masked GPIO bit(s) as needed */
 668         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 669         if (val == 0)
 670                 gpio_data &= ~mask;
 671         else
 672                 gpio_data |= mask;
 673         snd_hda_codec_write_cache(codec, nid, 0,
 674                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 675
 676         return change;
 677 }
 678 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 679         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 680           .info = alc_gpio_data_info, \
 681           .get = alc_gpio_data_get, \
 682           .put = alc_gpio_data_put, \
 683           .private_value = nid | (mask<<16) }
 684 #endif   /* CONFIG_SND_DEBUG */
 685
 686 /* A switch control to allow the enabling of the digital IO pins on the
 687  * ALC260.  This is incredibly simplistic; the intention of this control is
 688  * to provide something in the test model allowing digital outputs to be
 689  * identified if present.  If models are found which can utilise these
 690  * outputs a more complete mixer control can be devised for those models if
 691  * necessary.
 692  */
 693 #ifdef CONFIG_SND_DEBUG
 694 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 695
 696 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 697                               struct snd_ctl_elem_value *ucontrol)
 698 {
 699         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 700         hda_nid_t nid = kcontrol->private_value & 0xffff;
 701         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 702         long *valp = ucontrol->value.integer.value;
 703         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 704                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 705
 706         *valp = (val & mask) != 0;
 707         return 0;
 708 }
 709 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 710                               struct snd_ctl_elem_value *ucontrol)
 711 {
 712         signed int change;
 713         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 714         hda_nid_t nid = kcontrol->private_value & 0xffff;
 715         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 716         long val = *ucontrol->value.integer.value;
 717         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 718                                                     AC_VERB_GET_DIGI_CONVERT_1,
 719                                                     0x00);
 720
 721         /* Set/unset the masked control bit(s) as needed */
 722         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 723         if (val==0)
 724                 ctrl_data &= ~mask;
 725         else
 726                 ctrl_data |= mask;
 727         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 728                                   ctrl_data);
 729
 730         return change;
 731 }
 732 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 733         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 734           .info = alc_spdif_ctrl_info, \
 735           .get = alc_spdif_ctrl_get, \
 736           .put = alc_spdif_ctrl_put, \
 737           .private_value = nid | (mask<<16) }
 738 #endif   /* CONFIG_SND_DEBUG */
 739
 740 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 741  * Again, this is only used in the ALC26x test models to help identify when
 742  * the EAPD line must be asserted for features to work.
 743  */
 744 #ifdef CONFIG_SND_DEBUG
 745 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 746
 747 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 748                               struct snd_ctl_elem_value *ucontrol)
 749 {
 750         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 751         hda_nid_t nid = kcontrol->private_value & 0xffff;
 752         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 753         long *valp = ucontrol->value.integer.value;
 754         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 755                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 756
 757         *valp = (val & mask) != 0;
 758         return 0;
 759 }
 760
 761 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 762                               struct snd_ctl_elem_value *ucontrol)
 763 {
 764         int change;
 765         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 766         hda_nid_t nid = kcontrol->private_value & 0xffff;
 767         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 768         long val = *ucontrol->value.integer.value;
 769         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 770                                                     AC_VERB_GET_EAPD_BTLENABLE,
 771                                                     0x00);
 772
 773         /* Set/unset the masked control bit(s) as needed */
 774         change = (!val ? 0 : mask) != (ctrl_data & mask);
 775         if (!val)
 776                 ctrl_data &= ~mask;
 777         else
 778                 ctrl_data |= mask;
 779         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 780                                   ctrl_data);
 781
 782         return change;
 783 }
 784
 785 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 786         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 787           .info = alc_eapd_ctrl_info, \
 788           .get = alc_eapd_ctrl_get, \
 789           .put = alc_eapd_ctrl_put, \
 790           .private_value = nid | (mask<<16) }
 791 #endif   /* CONFIG_SND_DEBUG */
 792
 793 /*
 794  * set up the input pin config (depending on the given auto-pin type)
 795  */
 796 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 797                               int auto_pin_type)
 798 {
 799         unsigned int val = PIN_IN;
 800
 801         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 802                 unsigned int pincap;
 803                 pincap = snd_hda_query_pin_caps(codec, nid);
 804                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 805                 if (pincap & AC_PINCAP_VREF_80)
 806                         val = PIN_VREF80;
 807                 else if (pincap & AC_PINCAP_VREF_50)
 808                         val = PIN_VREF50;
 809                 else if (pincap & AC_PINCAP_VREF_100)
 810                         val = PIN_VREF100;
 811                 else if (pincap & AC_PINCAP_VREF_GRD)
 812                         val = PIN_VREFGRD;
 813         }
 814         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 815 }
 816
 817 /*
 818  */
 819 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 820 {
 821         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 822                 return;
 823         spec->mixers[spec->num_mixers++] = mix;
 824 }
 825
 826 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 827 {
 828         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 829                 return;
 830         spec->init_verbs[spec->num_init_verbs++] = verb;
 831 }
 832
 833 #ifdef CONFIG_PROC_FS
 834 /*
 835  * hook for proc
 836  */
 837 static void print_realtek_coef(struct snd_info_buffer *buffer,
 838                                struct hda_codec *codec, hda_nid_t nid)
 839 {
 840         int coeff;
 841
 842         if (nid != 0x20)
 843                 return;
 844         coeff = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_PROC_COEF, 0);
 845         snd_iprintf(buffer, "  Processing Coefficient: 0x%02x\n", coeff);
 846         coeff = snd_hda_codec_read(codec, nid, 0,
 847                                    AC_VERB_GET_COEF_INDEX, 0);
 848         snd_iprintf(buffer, "  Coefficient Index: 0x%02x\n", coeff);
 849 }
 850 #else
 851 #define print_realtek_coef      NULL
 852 #endif
 853
 854 /*
 855  * set up from the preset table
 856  */
 857 static void setup_preset(struct hda_codec *codec,
 858                          const struct alc_config_preset *preset)
 859 {
 860         struct alc_spec *spec = codec->spec;
 861         int i;
 862
 863         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 864                 add_mixer(spec, preset->mixers[i]);
 865         spec->cap_mixer = preset->cap_mixer;
 866         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 867              i++)
 868                 add_verb(spec, preset->init_verbs[i]);
 869
 870         spec->channel_mode = preset->channel_mode;
 871         spec->num_channel_mode = preset->num_channel_mode;
 872         spec->need_dac_fix = preset->need_dac_fix;
 873         spec->const_channel_count = preset->const_channel_count;
 874
 875         if (preset->const_channel_count)
 876                 spec->multiout.max_channels = preset->const_channel_count;
 877         else
 878                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 879         spec->ext_channel_count = spec->channel_mode[0].channels;
 880
 881         spec->multiout.num_dacs = preset->num_dacs;
 882         spec->multiout.dac_nids = preset->dac_nids;
 883         spec->multiout.dig_out_nid = preset->dig_out_nid;
 884         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 885         spec->multiout.hp_nid = preset->hp_nid;
 886
 887         spec->num_mux_defs = preset->num_mux_defs;
 888         if (!spec->num_mux_defs)
 889                 spec->num_mux_defs = 1;
 890         spec->input_mux = preset->input_mux;
 891
 892         spec->num_adc_nids = preset->num_adc_nids;
 893         spec->adc_nids = preset->adc_nids;
 894         spec->capsrc_nids = preset->capsrc_nids;
 895         spec->dig_in_nid = preset->dig_in_nid;
 896
 897         spec->unsol_event = preset->unsol_event;
 898         spec->init_hook = preset->init_hook;
 899 #ifdef CONFIG_SND_HDA_POWER_SAVE
 900         spec->loopback.amplist = preset->loopbacks;
 901 #endif
 902
 903         if (preset->setup)
 904                 preset->setup(codec);
 905 }
 906
 907 /* Enable GPIO mask and set output */
 908 static struct hda_verb alc_gpio1_init_verbs[] = {
 909         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
 910         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
 911         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
 912         { }
 913 };
 914
 915 static struct hda_verb alc_gpio2_init_verbs[] = {
 916         {0x01, AC_VERB_SET_GPIO_MASK, 0x02},
 917         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x02},
 918         {0x01, AC_VERB_SET_GPIO_DATA, 0x02},
 919         { }
 920 };
 921
 922 static struct hda_verb alc_gpio3_init_verbs[] = {
 923         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
 924         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x03},
 925         {0x01, AC_VERB_SET_GPIO_DATA, 0x03},
 926         { }
 927 };
 928
 929 /*
 930  * Fix hardware PLL issue
 931  * On some codecs, the analog PLL gating control must be off while
 932  * the default value is 1.
 933  */
 934 static void alc_fix_pll(struct hda_codec *codec)
 935 {
 936         struct alc_spec *spec = codec->spec;
 937         unsigned int val;
 938
 939         if (!spec->pll_nid)
 940                 return;
 941         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 942                             spec->pll_coef_idx);
 943         val = snd_hda_codec_read(codec, spec->pll_nid, 0,
 944                                  AC_VERB_GET_PROC_COEF, 0);
 945         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_COEF_INDEX,
 946                             spec->pll_coef_idx);
 947         snd_hda_codec_write(codec, spec->pll_nid, 0, AC_VERB_SET_PROC_COEF,
 948                             val & ~(1 << spec->pll_coef_bit));
 949 }
 950
 951 static void alc_fix_pll_init(struct hda_codec *codec, hda_nid_t nid,
 952                              unsigned int coef_idx, unsigned int coef_bit)
 953 {
 954         struct alc_spec *spec = codec->spec;
 955         spec->pll_nid = nid;
 956         spec->pll_coef_idx = coef_idx;
 957         spec->pll_coef_bit = coef_bit;
 958         alc_fix_pll(codec);
 959 }
 960
 961 static void alc_automute_pin(struct hda_codec *codec)
 962 {
 963         struct alc_spec *spec = codec->spec;
 964         unsigned int present, pincap;
 965         unsigned int nid = spec->autocfg.hp_pins[0];
 966         int i;
 967
 968         pincap = snd_hda_query_pin_caps(codec, nid);
 969         if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
 970                 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
 971         present = snd_hda_codec_read(codec, nid, 0,
 972                                      AC_VERB_GET_PIN_SENSE, 0);
 973         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
 974         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 975                 nid = spec->autocfg.speaker_pins[i];
 976                 if (!nid)
 977                         break;
 978                 snd_hda_codec_write(codec, nid, 0,
 979                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 980                                     spec->jack_present ? 0 : PIN_OUT);
 981         }
 982 }
 983
 984 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 985                                 hda_nid_t nid)
 986 {
 987         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 988         int i, nums;
 989
 990         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 991         for (i = 0; i < nums; i++)
 992                 if (conn[i] == nid)
 993                         return i;
 994         return -1;
 995 }
 996
 997 static void alc_mic_automute(struct hda_codec *codec)
 998 {
 999         struct alc_spec *spec = codec->spec;
1000         struct alc_mic_route *dead, *alive;
1001         unsigned int present, type;
1002         hda_nid_t cap_nid;
1003
1004         if (!spec->auto_mic)
1005                 return;
1006         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1007                 return;
1008         if (snd_BUG_ON(!spec->adc_nids))
1009                 return;
1010
1011         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1012
1013         present = snd_hda_codec_read(codec, spec->ext_mic.pin, 0,
1014                                      AC_VERB_GET_PIN_SENSE, 0);
1015         present &= AC_PINSENSE_PRESENCE;
1016         if (present) {
1017                 alive = &spec->ext_mic;
1018                 dead = &spec->int_mic;
1019         } else {
1020                 alive = &spec->int_mic;
1021                 dead = &spec->ext_mic;
1022         }
1023
1024         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1025         if (type == AC_WID_AUD_MIX) {
1026                 /* Matrix-mixer style (e.g. ALC882) */
1027                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1028                                          alive->mux_idx,
1029                                          HDA_AMP_MUTE, 0);
1030                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1031                                          dead->mux_idx,
1032                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1033         } else {
1034                 /* MUX style (e.g. ALC880) */
1035                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1036                                           AC_VERB_SET_CONNECT_SEL,
1037                                           alive->mux_idx);
1038         }
1039
1040         /* FIXME: analog mixer */
1041 }
1042
1043 /* unsolicited event for HP jack sensing */
1044 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1045 {
1046         if (codec->vendor_id == 0x10ec0880)
1047                 res >>= 28;
1048         else
1049                 res >>= 26;
1050         switch (res) {
1051         case ALC880_HP_EVENT:
1052                 alc_automute_pin(codec);
1053                 break;
1054         case ALC880_MIC_EVENT:
1055                 alc_mic_automute(codec);
1056                 break;
1057         }
1058 }
1059
1060 static void alc_inithook(struct hda_codec *codec)
1061 {
1062         alc_automute_pin(codec);
1063         alc_mic_automute(codec);
1064 }
1065
1066 /* additional initialization for ALC888 variants */
1067 static void alc888_coef_init(struct hda_codec *codec)
1068 {
1069         unsigned int tmp;
1070
1071         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1072         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1073         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1074         if ((tmp & 0xf0) == 0x20)
1075                 /* alc888S-VC */
1076                 snd_hda_codec_read(codec, 0x20, 0,
1077                                    AC_VERB_SET_PROC_COEF, 0x830);
1078          else
1079                  /* alc888-VB */
1080                  snd_hda_codec_read(codec, 0x20, 0,
1081                                     AC_VERB_SET_PROC_COEF, 0x3030);
1082 }
1083
1084 static void alc889_coef_init(struct hda_codec *codec)
1085 {
1086         unsigned int tmp;
1087
1088         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1089         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1090         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1091         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1092 }
1093
1094 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1095 {
1096         unsigned int tmp;
1097
1098         switch (type) {
1099         case ALC_INIT_GPIO1:
1100                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1101                 break;
1102         case ALC_INIT_GPIO2:
1103                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1104                 break;
1105         case ALC_INIT_GPIO3:
1106                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1107                 break;
1108         case ALC_INIT_DEFAULT:
1109                 switch (codec->vendor_id) {
1110                 case 0x10ec0260:
1111                         snd_hda_codec_write(codec, 0x0f, 0,
1112                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1113                         snd_hda_codec_write(codec, 0x10, 0,
1114                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1115                         break;
1116                 case 0x10ec0262:
1117                 case 0x10ec0267:
1118                 case 0x10ec0268:
1119                 case 0x10ec0269:
1120                 case 0x10ec0272:
1121                 case 0x10ec0660:
1122                 case 0x10ec0662:
1123                 case 0x10ec0663:
1124                 case 0x10ec0862:
1125                 case 0x10ec0889:
1126                         snd_hda_codec_write(codec, 0x14, 0,
1127                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1128                         snd_hda_codec_write(codec, 0x15, 0,
1129                                             AC_VERB_SET_EAPD_BTLENABLE, 2);
1130                         break;
1131                 }
1132                 switch (codec->vendor_id) {
1133                 case 0x10ec0260:
1134                         snd_hda_codec_write(codec, 0x1a, 0,
1135                                             AC_VERB_SET_COEF_INDEX, 7);
1136                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1137                                                  AC_VERB_GET_PROC_COEF, 0);
1138                         snd_hda_codec_write(codec, 0x1a, 0,
1139                                             AC_VERB_SET_COEF_INDEX, 7);
1140                         snd_hda_codec_write(codec, 0x1a, 0,
1141                                             AC_VERB_SET_PROC_COEF,
1142                                             tmp | 0x2010);
1143                         break;
1144                 case 0x10ec0262:
1145                 case 0x10ec0880:
1146                 case 0x10ec0882:
1147                 case 0x10ec0883:
1148                 case 0x10ec0885:
1149                 case 0x10ec0887:
1150                 case 0x10ec0889:
1151                         alc889_coef_init(codec);
1152                         break;
1153                 case 0x10ec0888:
1154                         alc888_coef_init(codec);
1155                         break;
1156                 case 0x10ec0267:
1157                 case 0x10ec0268:
1158                         snd_hda_codec_write(codec, 0x20, 0,
1159                                             AC_VERB_SET_COEF_INDEX, 7);
1160                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1161                                                  AC_VERB_GET_PROC_COEF, 0);
1162                         snd_hda_codec_write(codec, 0x20, 0,
1163                                             AC_VERB_SET_COEF_INDEX, 7);
1164                         snd_hda_codec_write(codec, 0x20, 0,
1165                                             AC_VERB_SET_PROC_COEF,
1166                                             tmp | 0x3000);
1167                         break;
1168                 }
1169                 break;
1170         }
1171 }
1172
1173 static void alc_init_auto_hp(struct hda_codec *codec)
1174 {
1175         struct alc_spec *spec = codec->spec;
1176
1177         if (!spec->autocfg.hp_pins[0])
1178                 return;
1179
1180         if (!spec->autocfg.speaker_pins[0]) {
1181                 if (spec->autocfg.line_out_pins[0] &&
1182                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1183                         spec->autocfg.speaker_pins[0] =
1184                                 spec->autocfg.line_out_pins[0];
1185                 else
1186                         return;
1187         }
1188
1189         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1190                     spec->autocfg.hp_pins[0]);
1191         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1192                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1193                                   AC_USRSP_EN | ALC880_HP_EVENT);
1194         spec->unsol_event = alc_sku_unsol_event;
1195 }
1196
1197 static void alc_init_auto_mic(struct hda_codec *codec)
1198 {
1199         struct alc_spec *spec = codec->spec;
1200         struct auto_pin_cfg *cfg = &spec->autocfg;
1201         hda_nid_t fixed, ext;
1202         int i;
1203
1204         /* there must be only two mic inputs exclusively */
1205         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1206                 if (cfg->input_pins[i])
1207                         return;
1208
1209         fixed = ext = 0;
1210         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1211                 hda_nid_t nid = cfg->input_pins[i];
1212                 unsigned int defcfg;
1213                 if (!nid)
1214                         return;
1215                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1216                 switch (get_defcfg_connect(defcfg)) {
1217                 case AC_JACK_PORT_FIXED:
1218                         if (fixed)
1219                                 return; /* already occupied */
1220                         fixed = nid;
1221                         break;
1222                 case AC_JACK_PORT_COMPLEX:
1223                         if (ext)
1224                                 return; /* already occupied */
1225                         ext = nid;
1226                         break;
1227                 default:
1228                         return; /* invalid entry */
1229                 }
1230         }
1231         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1232                 return; /* no unsol support */
1233         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1234                     ext, fixed);
1235         spec->ext_mic.pin = ext;
1236         spec->int_mic.pin = fixed;
1237         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1238         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1239         spec->auto_mic = 1;
1240         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1241                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1242                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1243         spec->unsol_event = alc_sku_unsol_event;
1244 }
1245
1246 /* check subsystem ID and set up device-specific initialization;
1247  * return 1 if initialized, 0 if invalid SSID
1248  */
1249 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1250  *      31 ~ 16 :       Manufacture ID
1251  *      15 ~ 8  :       SKU ID
1252  *      7  ~ 0  :       Assembly ID
1253  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1254  */
1255 static int alc_subsystem_id(struct hda_codec *codec,
1256                             hda_nid_t porta, hda_nid_t porte,
1257                             hda_nid_t portd)
1258 {
1259         unsigned int ass, tmp, i;
1260         unsigned nid;
1261         struct alc_spec *spec = codec->spec;
1262
1263         ass = codec->subsystem_id & 0xffff;
1264         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1265                 goto do_sku;
1266
1267         /* invalid SSID, check the special NID pin defcfg instead */
1268         /*
1269          * 31~30        : port connectivity
1270          * 29~21        : reserve
1271          * 20           : PCBEEP input
1272          * 19~16        : Check sum (15:1)
1273          * 15~1         : Custom
1274          * 0            : override
1275         */
1276         nid = 0x1d;
1277         if (codec->vendor_id == 0x10ec0260)
1278                 nid = 0x17;
1279         ass = snd_hda_codec_get_pincfg(codec, nid);
1280         snd_printd("realtek: No valid SSID, "
1281                    "checking pincfg 0x%08x for NID 0x%x\n",
1282                    ass, nid);
1283         if (!(ass & 1) && !(ass & 0x100000))
1284                 return 0;
1285         if ((ass >> 30) != 1)   /* no physical connection */
1286                 return 0;
1287
1288         /* check sum */
1289         tmp = 0;
1290         for (i = 1; i < 16; i++) {
1291                 if ((ass >> i) & 1)
1292                         tmp++;
1293         }
1294         if (((ass >> 16) & 0xf) != tmp)
1295                 return 0;
1296 do_sku:
1297         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1298                    ass & 0xffff, codec->vendor_id);
1299         /*
1300          * 0 : override
1301          * 1 :  Swap Jack
1302          * 2 : 0 --> Desktop, 1 --> Laptop
1303          * 3~5 : External Amplifier control
1304          * 7~6 : Reserved
1305         */
1306         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1307         switch (tmp) {
1308         case 1:
1309                 spec->init_amp = ALC_INIT_GPIO1;
1310                 break;
1311         case 3:
1312                 spec->init_amp = ALC_INIT_GPIO2;
1313                 break;
1314         case 7:
1315                 spec->init_amp = ALC_INIT_GPIO3;
1316                 break;
1317         case 5:
1318                 spec->init_amp = ALC_INIT_DEFAULT;
1319                 break;
1320         }
1321
1322         /* is laptop or Desktop and enable the function "Mute internal speaker
1323          * when the external headphone out jack is plugged"
1324          */
1325         if (!(ass & 0x8000))
1326                 return 1;
1327         /*
1328          * 10~8 : Jack location
1329          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1330          * 14~13: Resvered
1331          * 15   : 1 --> enable the function "Mute internal speaker
1332          *              when the external headphone out jack is plugged"
1333          */
1334         if (!spec->autocfg.hp_pins[0]) {
1335                 hda_nid_t nid;
1336                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1337                 if (tmp == 0)
1338                         nid = porta;
1339                 else if (tmp == 1)
1340                         nid = porte;
1341                 else if (tmp == 2)
1342                         nid = portd;
1343                 else
1344                         return 1;
1345                 for (i = 0; i < spec->autocfg.line_outs; i++)
1346                         if (spec->autocfg.line_out_pins[i] == nid)
1347                                 return 1;
1348                 spec->autocfg.hp_pins[0] = nid;
1349         }
1350
1351         alc_init_auto_hp(codec);
1352         alc_init_auto_mic(codec);
1353         return 1;
1354 }
1355
1356 static void alc_ssid_check(struct hda_codec *codec,
1357                            hda_nid_t porta, hda_nid_t porte, hda_nid_t portd)
1358 {
1359         if (!alc_subsystem_id(codec, porta, porte, portd)) {
1360                 struct alc_spec *spec = codec->spec;
1361                 snd_printd("realtek: "
1362                            "Enable default setup for auto mode as fallback\n");
1363                 spec->init_amp = ALC_INIT_DEFAULT;
1364                 alc_init_auto_hp(codec);
1365                 alc_init_auto_mic(codec);
1366         }
1367 }
1368
1369 /*
1370  * Fix-up pin default configurations and add default verbs
1371  */
1372
1373 struct alc_pincfg {
1374         hda_nid_t nid;
1375         u32 val;
1376 };
1377
1378 struct alc_fixup {
1379         const struct alc_pincfg *pins;
1380         const struct hda_verb *verbs;
1381 };
1382
1383 static void alc_pick_fixup(struct hda_codec *codec,
1384                            const struct snd_pci_quirk *quirk,
1385                            const struct alc_fixup *fix)
1386 {
1387         const struct alc_pincfg *cfg;
1388
1389         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1390         if (!quirk)
1391                 return;
1392
1393         fix += quirk->value;
1394         cfg = fix->pins;
1395         if (cfg) {
1396                 for (; cfg->nid; cfg++)
1397                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1398         }
1399         if (fix->verbs)
1400                 add_verb(codec->spec, fix->verbs);
1401 }
1402
1403 /*
1404  * ALC888
1405  */
1406
1407 /*
1408  * 2ch mode
1409  */
1410 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1411 /* Mic-in jack as mic in */
1412         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1413         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1414 /* Line-in jack as Line in */
1415         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1416         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1417 /* Line-Out as Front */
1418         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1419         { } /* end */
1420 };
1421
1422 /*
1423  * 4ch mode
1424  */
1425 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1426 /* Mic-in jack as mic in */
1427         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1428         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1429 /* Line-in jack as Surround */
1430         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1431         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1432 /* Line-Out as Front */
1433         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1434         { } /* end */
1435 };
1436
1437 /*
1438  * 6ch mode
1439  */
1440 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1441 /* Mic-in jack as CLFE */
1442         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1443         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1444 /* Line-in jack as Surround */
1445         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1446         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1447 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1448         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1449         { } /* end */
1450 };
1451
1452 /*
1453  * 8ch mode
1454  */
1455 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1456 /* Mic-in jack as CLFE */
1457         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1458         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1459 /* Line-in jack as Surround */
1460         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1461         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1462 /* Line-Out as Side */
1463         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1464         { } /* end */
1465 };
1466
1467 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1468         { 2, alc888_4ST_ch2_intel_init },
1469         { 4, alc888_4ST_ch4_intel_init },
1470         { 6, alc888_4ST_ch6_intel_init },
1471         { 8, alc888_4ST_ch8_intel_init },
1472 };
1473
1474 /*
1475  * ALC888 Fujitsu Siemens Amillo xa3530
1476  */
1477
1478 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1479 /* Front Mic: set to PIN_IN (empty by default) */
1480         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1481 /* Connect Internal HP to Front */
1482         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1483         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1484         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1485 /* Connect Bass HP to Front */
1486         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1487         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1488         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1489 /* Connect Line-Out side jack (SPDIF) to Side */
1490         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1491         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1492         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1493 /* Connect Mic jack to CLFE */
1494         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1495         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1496         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1497 /* Connect Line-in jack to Surround */
1498         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1499         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1500         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1501 /* Connect HP out jack to Front */
1502         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1503         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1504         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1505 /* Enable unsolicited event for HP jack and Line-out jack */
1506         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1507         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1508         {}
1509 };
1510
1511 static void alc_automute_amp(struct hda_codec *codec)
1512 {
1513         struct alc_spec *spec = codec->spec;
1514         unsigned int val, mute, pincap;
1515         hda_nid_t nid;
1516         int i;
1517
1518         spec->jack_present = 0;
1519         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1520                 nid = spec->autocfg.hp_pins[i];
1521                 if (!nid)
1522                         break;
1523                 pincap = snd_hda_query_pin_caps(codec, nid);
1524                 if (pincap & AC_PINCAP_TRIG_REQ) /* need trigger? */
1525                         snd_hda_codec_read(codec, nid, 0,
1526                                            AC_VERB_SET_PIN_SENSE, 0);
1527                 val = snd_hda_codec_read(codec, nid, 0,
1528                                          AC_VERB_GET_PIN_SENSE, 0);
1529                 if (val & AC_PINSENSE_PRESENCE) {
1530                         spec->jack_present = 1;
1531                         break;
1532                 }
1533         }
1534
1535         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1536         /* Toggle internal speakers muting */
1537         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1538                 nid = spec->autocfg.speaker_pins[i];
1539                 if (!nid)
1540                         break;
1541                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1542                                          HDA_AMP_MUTE, mute);
1543         }
1544 }
1545
1546 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1547                                          unsigned int res)
1548 {
1549         if (codec->vendor_id == 0x10ec0880)
1550                 res >>= 28;
1551         else
1552                 res >>= 26;
1553         if (res == ALC880_HP_EVENT)
1554                 alc_automute_amp(codec);
1555 }
1556
1557 static void alc889_automute_setup(struct hda_codec *codec)
1558 {
1559         struct alc_spec *spec = codec->spec;
1560
1561         spec->autocfg.hp_pins[0] = 0x15;
1562         spec->autocfg.speaker_pins[0] = 0x14;
1563         spec->autocfg.speaker_pins[1] = 0x16;
1564         spec->autocfg.speaker_pins[2] = 0x17;
1565         spec->autocfg.speaker_pins[3] = 0x19;
1566         spec->autocfg.speaker_pins[4] = 0x1a;
1567 }
1568
1569 static void alc889_intel_init_hook(struct hda_codec *codec)
1570 {
1571         alc889_coef_init(codec);
1572         alc_automute_amp(codec);
1573 }
1574
1575 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1576 {
1577         struct alc_spec *spec = codec->spec;
1578
1579         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1580         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1581         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1582         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1583 }
1584
1585 /*
1586  * ALC888 Acer Aspire 4930G model
1587  */
1588
1589 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1590 /* Front Mic: set to PIN_IN (empty by default) */
1591         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1592 /* Unselect Front Mic by default in input mixer 3 */
1593         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1594 /* Enable unsolicited event for HP jack */
1595         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1596 /* Connect Internal HP to front */
1597         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1598         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1599         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1600 /* Connect HP out to front */
1601         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1602         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1603         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1604         { }
1605 };
1606
1607 /*
1608  * ALC888 Acer Aspire 6530G model
1609  */
1610
1611 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1612 /* Bias voltage on for external mic port */
1613         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1614 /* Front Mic: set to PIN_IN (empty by default) */
1615         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1616 /* Unselect Front Mic by default in input mixer 3 */
1617         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1618 /* Enable unsolicited event for HP jack */
1619         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1620 /* Enable speaker output */
1621         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1622         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1623 /* Enable headphone output */
1624         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1625         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1626         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1627         { }
1628 };
1629
1630 /*
1631  * ALC889 Acer Aspire 8930G model
1632  */
1633
1634 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1635 /* Front Mic: set to PIN_IN (empty by default) */
1636         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1637 /* Unselect Front Mic by default in input mixer 3 */
1638         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1639 /* Enable unsolicited event for HP jack */
1640         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1641 /* Connect Internal Front to Front */
1642         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1643         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1644         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1645 /* Connect Internal Rear to Rear */
1646         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1647         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1648         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1649 /* Connect Internal CLFE to CLFE */
1650         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1651         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1652         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1653 /* Connect HP out to Front */
1654         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1655         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1656         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1657 /* Enable all DACs */
1658 /*  DAC DISABLE/MUTE 1? */
1659 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1660         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1661         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1662 /*  DAC DISABLE/MUTE 2? */
1663 /*  some bit here disables the other DACs. Init=0x4900 */
1664         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1665         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1666 /* Enable amplifiers */
1667         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1668         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
1669 /* DMIC fix
1670  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1671  * which makes the stereo useless. However, either the mic or the ALC889
1672  * makes the signal become a difference/sum signal instead of standard
1673  * stereo, which is annoying. So instead we flip this bit which makes the
1674  * codec replicate the sum signal to both channels, turning it into a
1675  * normal mono mic.
1676  */
1677 /*  DMIC_CONTROL? Init value = 0x0001 */
1678         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1679         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1680         { }
1681 };
1682
1683 static struct hda_input_mux alc888_2_capture_sources[2] = {
1684         /* Front mic only available on one ADC */
1685         {
1686                 .num_items = 4,
1687                 .items = {
1688                         { "Mic", 0x0 },
1689                         { "Line", 0x2 },
1690                         { "CD", 0x4 },
1691                         { "Front Mic", 0xb },
1692                 },
1693         },
1694         {
1695                 .num_items = 3,
1696                 .items = {
1697                         { "Mic", 0x0 },
1698                         { "Line", 0x2 },
1699                         { "CD", 0x4 },
1700                 },
1701         }
1702 };
1703
1704 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1705         /* Interal mic only available on one ADC */
1706         {
1707                 .num_items = 5,
1708                 .items = {
1709                         { "Ext Mic", 0x0 },
1710                         { "Line In", 0x2 },
1711                         { "CD", 0x4 },
1712                         { "Input Mix", 0xa },
1713                         { "Int Mic", 0xb },
1714                 },
1715         },
1716         {
1717                 .num_items = 4,
1718                 .items = {
1719                         { "Ext Mic", 0x0 },
1720                         { "Line In", 0x2 },
1721                         { "CD", 0x4 },
1722                         { "Input Mix", 0xa },
1723                 },
1724         }
1725 };
1726
1727 static struct hda_input_mux alc889_capture_sources[3] = {
1728         /* Digital mic only available on first "ADC" */
1729         {
1730                 .num_items = 5,
1731                 .items = {
1732                         { "Mic", 0x0 },
1733                         { "Line", 0x2 },
1734                         { "CD", 0x4 },
1735                         { "Front Mic", 0xb },
1736                         { "Input Mix", 0xa },
1737                 },
1738         },
1739         {
1740                 .num_items = 4,
1741                 .items = {
1742                         { "Mic", 0x0 },
1743                         { "Line", 0x2 },
1744                         { "CD", 0x4 },
1745                         { "Input Mix", 0xa },
1746                 },
1747         },
1748         {
1749                 .num_items = 4,
1750                 .items = {
1751                         { "Mic", 0x0 },
1752                         { "Line", 0x2 },
1753                         { "CD", 0x4 },
1754                         { "Input Mix", 0xa },
1755                 },
1756         }
1757 };
1758
1759 static struct snd_kcontrol_new alc888_base_mixer[] = {
1760         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1761         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1762         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1763         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1764         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1765                 HDA_OUTPUT),
1766         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1767         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1768         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1769         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1770         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1771         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1772         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1773         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1774         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1775         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1776         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1777         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1778         { } /* end */
1779 };
1780
1781 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1782 {
1783         struct alc_spec *spec = codec->spec;
1784
1785         spec->autocfg.hp_pins[0] = 0x15;
1786         spec->autocfg.speaker_pins[0] = 0x14;
1787 }
1788
1789 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1790 {
1791         struct alc_spec *spec = codec->spec;
1792
1793         spec->autocfg.hp_pins[0] = 0x15;
1794         spec->autocfg.speaker_pins[0] = 0x14;
1795         spec->autocfg.speaker_pins[1] = 0x16;
1796         spec->autocfg.speaker_pins[2] = 0x17;
1797 }
1798
1799 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1800 {
1801         struct alc_spec *spec = codec->spec;
1802
1803         spec->autocfg.hp_pins[0] = 0x15;
1804         spec->autocfg.speaker_pins[0] = 0x14;
1805         spec->autocfg.speaker_pins[1] = 0x16;
1806         spec->autocfg.speaker_pins[2] = 0x1b;
1807 }
1808
1809 /*
1810  * ALC880 3-stack model
1811  *
1812  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1813  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1814  *                 F-Mic = 0x1b, HP = 0x19
1815  */
1816
1817 static hda_nid_t alc880_dac_nids[4] = {
1818         /* front, rear, clfe, rear_surr */
1819         0x02, 0x05, 0x04, 0x03
1820 };
1821
1822 static hda_nid_t alc880_adc_nids[3] = {
1823         /* ADC0-2 */
1824         0x07, 0x08, 0x09,
1825 };
1826
1827 /* The datasheet says the node 0x07 is connected from inputs,
1828  * but it shows zero connection in the real implementation on some devices.
1829  * Note: this is a 915GAV bug, fixed on 915GLV
1830  */
1831 static hda_nid_t alc880_adc_nids_alt[2] = {
1832         /* ADC1-2 */
1833         0x08, 0x09,
1834 };
1835
1836 #define ALC880_DIGOUT_NID       0x06
1837 #define ALC880_DIGIN_NID        0x0a
1838
1839 static struct hda_input_mux alc880_capture_source = {
1840         .num_items = 4,
1841         .items = {
1842                 { "Mic", 0x0 },
1843                 { "Front Mic", 0x3 },
1844                 { "Line", 0x2 },
1845                 { "CD", 0x4 },
1846         },
1847 };
1848
1849 /* channel source setting (2/6 channel selection for 3-stack) */
1850 /* 2ch mode */
1851 static struct hda_verb alc880_threestack_ch2_init[] = {
1852         /* set line-in to input, mute it */
1853         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1854         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1855         /* set mic-in to input vref 80%, mute it */
1856         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1857         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1858         { } /* end */
1859 };
1860
1861 /* 6ch mode */
1862 static struct hda_verb alc880_threestack_ch6_init[] = {
1863         /* set line-in to output, unmute it */
1864         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1865         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1866         /* set mic-in to output, unmute it */
1867         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1868         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1869         { } /* end */
1870 };
1871
1872 static struct hda_channel_mode alc880_threestack_modes[2] = {
1873         { 2, alc880_threestack_ch2_init },
1874         { 6, alc880_threestack_ch6_init },
1875 };
1876
1877 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1878         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1879         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1880         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1881         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1882         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1883         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1884         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1885         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1886         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1887         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1888         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1889         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1890         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1891         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1892         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1893         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1894         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1895         {
1896                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1897                 .name = "Channel Mode",
1898                 .info = alc_ch_mode_info,
1899                 .get = alc_ch_mode_get,
1900                 .put = alc_ch_mode_put,
1901         },
1902         { } /* end */
1903 };
1904
1905 /* capture mixer elements */
1906 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1907                             struct snd_ctl_elem_info *uinfo)
1908 {
1909         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1910         struct alc_spec *spec = codec->spec;
1911         int err;
1912
1913         mutex_lock(&codec->control_mutex);
1914         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1915                                                       HDA_INPUT);
1916         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1917         mutex_unlock(&codec->control_mutex);
1918         return err;
1919 }
1920
1921 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1922                            unsigned int size, unsigned int __user *tlv)
1923 {
1924         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1925         struct alc_spec *spec = codec->spec;
1926         int err;
1927
1928         mutex_lock(&codec->control_mutex);
1929         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1930                                                       HDA_INPUT);
1931         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1932         mutex_unlock(&codec->control_mutex);
1933         return err;
1934 }
1935
1936 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1937                              struct snd_ctl_elem_value *ucontrol);
1938
1939 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1940                                  struct snd_ctl_elem_value *ucontrol,
1941                                  getput_call_t func)
1942 {
1943         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1944         struct alc_spec *spec = codec->spec;
1945         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1946         int err;
1947
1948         mutex_lock(&codec->control_mutex);
1949         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1950                                                       3, 0, HDA_INPUT);
1951         err = func(kcontrol, ucontrol);
1952         mutex_unlock(&codec->control_mutex);
1953         return err;
1954 }
1955
1956 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1957                            struct snd_ctl_elem_value *ucontrol)
1958 {
1959         return alc_cap_getput_caller(kcontrol, ucontrol,
1960                                      snd_hda_mixer_amp_volume_get);
1961 }
1962
1963 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
1964                            struct snd_ctl_elem_value *ucontrol)
1965 {
1966         return alc_cap_getput_caller(kcontrol, ucontrol,
1967                                      snd_hda_mixer_amp_volume_put);
1968 }
1969
1970 /* capture mixer elements */
1971 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
1972
1973 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
1974                           struct snd_ctl_elem_value *ucontrol)
1975 {
1976         return alc_cap_getput_caller(kcontrol, ucontrol,
1977                                      snd_hda_mixer_amp_switch_get);
1978 }
1979
1980 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
1981                           struct snd_ctl_elem_value *ucontrol)
1982 {
1983         return alc_cap_getput_caller(kcontrol, ucontrol,
1984                                      snd_hda_mixer_amp_switch_put);
1985 }
1986
1987 #define _DEFINE_CAPMIX(num) \
1988         { \
1989                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1990                 .name = "Capture Switch", \
1991                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1992                 .count = num, \
1993                 .info = alc_cap_sw_info, \
1994                 .get = alc_cap_sw_get, \
1995                 .put = alc_cap_sw_put, \
1996         }, \
1997         { \
1998                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
1999                 .name = "Capture Volume", \
2000                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2001                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2002                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2003                 .count = num, \
2004                 .info = alc_cap_vol_info, \
2005                 .get = alc_cap_vol_get, \
2006                 .put = alc_cap_vol_put, \
2007                 .tlv = { .c = alc_cap_vol_tlv }, \
2008         }
2009
2010 #define _DEFINE_CAPSRC(num) \
2011         { \
2012                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2013                 /* .name = "Capture Source", */ \
2014                 .name = "Input Source", \
2015                 .count = num, \
2016                 .info = alc_mux_enum_info, \
2017                 .get = alc_mux_enum_get, \
2018                 .put = alc_mux_enum_put, \
2019         }
2020
2021 #define DEFINE_CAPMIX(num) \
2022 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2023         _DEFINE_CAPMIX(num),                                  \
2024         _DEFINE_CAPSRC(num),                                  \
2025         { } /* end */                                         \
2026 }
2027
2028 #define DEFINE_CAPMIX_NOSRC(num) \
2029 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2030         _DEFINE_CAPMIX(num),                                        \
2031         { } /* end */                                               \
2032 }
2033
2034 /* up to three ADCs */
2035 DEFINE_CAPMIX(1);
2036 DEFINE_CAPMIX(2);
2037 DEFINE_CAPMIX(3);
2038 DEFINE_CAPMIX_NOSRC(1);
2039 DEFINE_CAPMIX_NOSRC(2);
2040 DEFINE_CAPMIX_NOSRC(3);
2041
2042 /*
2043  * ALC880 5-stack model
2044  *
2045  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2046  *      Side = 0x02 (0xd)
2047  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2048  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2049  */
2050
2051 /* additional mixers to alc880_three_stack_mixer */
2052 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2053         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2054         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2055         { } /* end */
2056 };
2057
2058 /* channel source setting (6/8 channel selection for 5-stack) */
2059 /* 6ch mode */
2060 static struct hda_verb alc880_fivestack_ch6_init[] = {
2061         /* set line-in to input, mute it */
2062         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2063         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2064         { } /* end */
2065 };
2066
2067 /* 8ch mode */
2068 static struct hda_verb alc880_fivestack_ch8_init[] = {
2069         /* set line-in to output, unmute it */
2070         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2071         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2072         { } /* end */
2073 };
2074
2075 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2076         { 6, alc880_fivestack_ch6_init },
2077         { 8, alc880_fivestack_ch8_init },
2078 };
2079
2080
2081 /*
2082  * ALC880 6-stack model
2083  *
2084  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2085  *      Side = 0x05 (0x0f)
2086  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2087  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2088  */
2089
2090 static hda_nid_t alc880_6st_dac_nids[4] = {
2091         /* front, rear, clfe, rear_surr */
2092         0x02, 0x03, 0x04, 0x05
2093 };
2094
2095 static struct hda_input_mux alc880_6stack_capture_source = {
2096         .num_items = 4,
2097         .items = {
2098                 { "Mic", 0x0 },
2099                 { "Front Mic", 0x1 },
2100                 { "Line", 0x2 },
2101                 { "CD", 0x4 },
2102         },
2103 };
2104
2105 /* fixed 8-channels */
2106 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2107         { 8, NULL },
2108 };
2109
2110 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2111         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2112         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2113         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2114         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2115         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2116         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2117         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2118         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2119         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2120         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2121         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2122         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2123         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2124         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2125         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2126         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2127         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2128         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2129         {
2130                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2131                 .name = "Channel Mode",
2132                 .info = alc_ch_mode_info,
2133                 .get = alc_ch_mode_get,
2134                 .put = alc_ch_mode_put,
2135         },
2136         { } /* end */
2137 };
2138
2139
2140 /*
2141  * ALC880 W810 model
2142  *
2143  * W810 has rear IO for:
2144  * Front (DAC 02)
2145  * Surround (DAC 03)
2146  * Center/LFE (DAC 04)
2147  * Digital out (06)
2148  *
2149  * The system also has a pair of internal speakers, and a headphone jack.
2150  * These are both connected to Line2 on the codec, hence to DAC 02.
2151  *
2152  * There is a variable resistor to control the speaker or headphone
2153  * volume. This is a hardware-only device without a software API.
2154  *
2155  * Plugging headphones in will disable the internal speakers. This is
2156  * implemented in hardware, not via the driver using jack sense. In
2157  * a similar fashion, plugging into the rear socket marked "front" will
2158  * disable both the speakers and headphones.
2159  *
2160  * For input, there's a microphone jack, and an "audio in" jack.
2161  * These may not do anything useful with this driver yet, because I
2162  * haven't setup any initialization verbs for these yet...
2163  */
2164
2165 static hda_nid_t alc880_w810_dac_nids[3] = {
2166         /* front, rear/surround, clfe */
2167         0x02, 0x03, 0x04
2168 };
2169
2170 /* fixed 6 channels */
2171 static struct hda_channel_mode alc880_w810_modes[1] = {
2172         { 6, NULL }
2173 };
2174
2175 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2176 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2177         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2178         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2179         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2180         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2181         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2182         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2183         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2184         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2185         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2186         { } /* end */
2187 };
2188
2189
2190 /*
2191  * Z710V model
2192  *
2193  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2194  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2195  *                 Line = 0x1a
2196  */
2197
2198 static hda_nid_t alc880_z71v_dac_nids[1] = {
2199         0x02
2200 };
2201 #define ALC880_Z71V_HP_DAC      0x03
2202
2203 /* fixed 2 channels */
2204 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2205         { 2, NULL }
2206 };
2207
2208 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2209         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2210         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2211         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2212         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2213         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2214         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2215         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2216         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2217         { } /* end */
2218 };
2219
2220
2221 /*
2222  * ALC880 F1734 model
2223  *
2224  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2225  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2226  */
2227
2228 static hda_nid_t alc880_f1734_dac_nids[1] = {
2229         0x03
2230 };
2231 #define ALC880_F1734_HP_DAC     0x02
2232
2233 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2234         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2235         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2236         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2237         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2238         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2239         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2240         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2241         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2242         { } /* end */
2243 };
2244
2245 static struct hda_input_mux alc880_f1734_capture_source = {
2246         .num_items = 2,
2247         .items = {
2248                 { "Mic", 0x1 },
2249                 { "CD", 0x4 },
2250         },
2251 };
2252
2253
2254 /*
2255  * ALC880 ASUS model
2256  *
2257  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2258  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2259  *  Mic = 0x18, Line = 0x1a
2260  */
2261
2262 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2263 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2264
2265 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2266         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2267         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2268         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2269         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2270         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2271         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2272         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2273         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2274         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2275         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2276         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2277         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2278         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2279         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2280         {
2281                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2282                 .name = "Channel Mode",
2283                 .info = alc_ch_mode_info,
2284                 .get = alc_ch_mode_get,
2285                 .put = alc_ch_mode_put,
2286         },
2287         { } /* end */
2288 };
2289
2290 /*
2291  * ALC880 ASUS W1V model
2292  *
2293  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2294  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2295  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2296  */
2297
2298 /* additional mixers to alc880_asus_mixer */
2299 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2300         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2301         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2302         { } /* end */
2303 };
2304
2305 /* TCL S700 */
2306 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2307         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2308         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2309         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2310         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2311         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2312         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2313         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2314         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2315         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2316         { } /* end */
2317 };
2318
2319 /* Uniwill */
2320 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2321         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2322         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2323         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2324         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2325         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2326         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2327         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2328         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2329         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2330         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2331         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2332         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2333         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2334         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2335         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2336         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2337         {
2338                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2339                 .name = "Channel Mode",
2340                 .info = alc_ch_mode_info,
2341                 .get = alc_ch_mode_get,
2342                 .put = alc_ch_mode_put,
2343         },
2344         { } /* end */
2345 };
2346
2347 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2348         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2349         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2350         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2351         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2352         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2353         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2354         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2355         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2356         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2357         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2358         { } /* end */
2359 };
2360
2361 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2362         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2363         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2364         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2365         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2366         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2367         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2368         { } /* end */
2369 };
2370
2371 /*
2372  * virtual master controls
2373  */
2374
2375 /*
2376  * slave controls for virtual master
2377  */
2378 static const char *alc_slave_vols[] = {
2379         "Front Playback Volume",
2380         "Surround Playback Volume",
2381         "Center Playback Volume",
2382         "LFE Playback Volume",
2383         "Side Playback Volume",
2384         "Headphone Playback Volume",
2385         "Speaker Playback Volume",
2386         "Mono Playback Volume",
2387         "Line-Out Playback Volume",
2388         "PCM Playback Volume",
2389         NULL,
2390 };
2391
2392 static const char *alc_slave_sws[] = {
2393         "Front Playback Switch",
2394         "Surround Playback Switch",
2395         "Center Playback Switch",
2396         "LFE Playback Switch",
2397         "Side Playback Switch",
2398         "Headphone Playback Switch",
2399         "Speaker Playback Switch",
2400         "Mono Playback Switch",
2401         "IEC958 Playback Switch",
2402         NULL,
2403 };
2404
2405 /*
2406  * build control elements
2407  */
2408
2409 static void alc_free_kctls(struct hda_codec *codec);
2410
2411 /* additional beep mixers; the actual parameters are overwritten at build */
2412 static struct snd_kcontrol_new alc_beep_mixer[] = {
2413         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2414         HDA_CODEC_MUTE("Beep Playback Switch", 0, 0, HDA_INPUT),
2415         { } /* end */
2416 };
2417
2418 static int alc_build_controls(struct hda_codec *codec)
2419 {
2420         struct alc_spec *spec = codec->spec;
2421         int err;
2422         int i;
2423
2424         for (i = 0; i < spec->num_mixers; i++) {
2425                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2426                 if (err < 0)
2427                         return err;
2428         }
2429         if (spec->cap_mixer) {
2430                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2431                 if (err < 0)
2432                         return err;
2433         }
2434         if (spec->multiout.dig_out_nid) {
2435                 err = snd_hda_create_spdif_out_ctls(codec,
2436                                                     spec->multiout.dig_out_nid);
2437                 if (err < 0)
2438                         return err;
2439                 if (!spec->no_analog) {
2440                         err = snd_hda_create_spdif_share_sw(codec,
2441                                                             &spec->multiout);
2442                         if (err < 0)
2443                                 return err;
2444                         spec->multiout.share_spdif = 1;
2445                 }
2446         }
2447         if (spec->dig_in_nid) {
2448                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2449                 if (err < 0)
2450                         return err;
2451         }
2452
2453         /* create beep controls if needed */
2454         if (spec->beep_amp) {
2455                 struct snd_kcontrol_new *knew;
2456                 for (knew = alc_beep_mixer; knew->name; knew++) {
2457                         struct snd_kcontrol *kctl;
2458                         kctl = snd_ctl_new1(knew, codec);
2459                         if (!kctl)
2460                                 return -ENOMEM;
2461                         kctl->private_value = spec->beep_amp;
2462                         err = snd_hda_ctl_add(codec, kctl);
2463                         if (err < 0)
2464                                 return err;
2465                 }
2466         }
2467
2468         /* if we have no master control, let's create it */
2469         if (!spec->no_analog &&
2470             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2471                 unsigned int vmaster_tlv[4];
2472                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2473                                         HDA_OUTPUT, vmaster_tlv);
2474                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2475                                           vmaster_tlv, alc_slave_vols);
2476                 if (err < 0)
2477                         return err;
2478         }
2479         if (!spec->no_analog &&
2480             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2481                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2482                                           NULL, alc_slave_sws);
2483                 if (err < 0)
2484                         return err;
2485         }
2486
2487         alc_free_kctls(codec); /* no longer needed */
2488         return 0;
2489 }
2490
2491
2492 /*
2493  * initialize the codec volumes, etc
2494  */
2495
2496 /*
2497  * generic initialization of ADC, input mixers and output mixers
2498  */
2499 static struct hda_verb alc880_volume_init_verbs[] = {
2500         /*
2501          * Unmute ADC0-2 and set the default input to mic-in
2502          */
2503         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2504         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2505         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2506         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2507         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2508         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2509
2510         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2511          * mixer widget
2512          * Note: PASD motherboards uses the Line In 2 as the input for front
2513          * panel mic (mic 2)
2514          */
2515         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2516         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2517         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2518         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2519         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2520         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2521         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2522         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2523
2524         /*
2525          * Set up output mixers (0x0c - 0x0f)
2526          */
2527         /* set vol=0 to output mixers */
2528         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2529         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2530         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2531         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2532         /* set up input amps for analog loopback */
2533         /* Amp Indices: DAC = 0, mixer = 1 */
2534         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2535         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2536         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2537         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2538         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2539         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2540         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2541         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2542
2543         { }
2544 };
2545
2546 /*
2547  * 3-stack pin configuration:
2548  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2549  */
2550 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2551         /*
2552          * preset connection lists of input pins
2553          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2554          */
2555         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2556         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2557         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2558
2559         /*
2560          * Set pin mode and muting
2561          */
2562         /* set front pin widgets 0x14 for output */
2563         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2564         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2565         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2566         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2567         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2568         /* Mic2 (as headphone out) for HP output */
2569         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2570         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2571         /* Line In pin widget for input */
2572         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2573         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2574         /* Line2 (as front mic) pin widget for input and vref at 80% */
2575         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2576         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2577         /* CD pin widget for input */
2578         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2579
2580         { }
2581 };
2582
2583 /*
2584  * 5-stack pin configuration:
2585  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2586  * line-in/side = 0x1a, f-mic = 0x1b
2587  */
2588 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2589         /*
2590          * preset connection lists of input pins
2591          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2592          */
2593         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2594         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2595
2596         /*
2597          * Set pin mode and muting
2598          */
2599         /* set pin widgets 0x14-0x17 for output */
2600         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2601         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2602         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2603         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2604         /* unmute pins for output (no gain on this amp) */
2605         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2606         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2607         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2608         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2609
2610         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2611         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2612         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2613         /* Mic2 (as headphone out) for HP output */
2614         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2615         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2616         /* Line In pin widget for input */
2617         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2618         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2619         /* Line2 (as front mic) pin widget for input and vref at 80% */
2620         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2621         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2622         /* CD pin widget for input */
2623         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2624
2625         { }
2626 };
2627
2628 /*
2629  * W810 pin configuration:
2630  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2631  */
2632 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2633         /* hphone/speaker input selector: front DAC */
2634         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2635
2636         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2637         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2638         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2639         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2640         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2641         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2642
2643         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2644         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2645
2646         { }
2647 };
2648
2649 /*
2650  * Z71V pin configuration:
2651  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2652  */
2653 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2654         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2655         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2656         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2657         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2658
2659         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2660         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2661         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2662         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2663
2664         { }
2665 };
2666
2667 /*
2668  * 6-stack pin configuration:
2669  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2670  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2671  */
2672 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2673         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2674
2675         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2676         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2677         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2678         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2679         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2680         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2681         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2682         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2683
2684         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2685         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2686         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2687         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2688         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2689         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2690         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2691         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2692         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2693
2694         { }
2695 };
2696
2697 /*
2698  * Uniwill pin configuration:
2699  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2700  * line = 0x1a
2701  */
2702 static struct hda_verb alc880_uniwill_init_verbs[] = {
2703         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2704
2705         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2706         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2707         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2708         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2709         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2710         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2711         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2712         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2713         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2714         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2715         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2716         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2717         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2718         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2719
2720         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2721         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2722         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2723         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2724         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2725         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2726         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2727         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2728         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2729
2730         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2731         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2732
2733         { }
2734 };
2735
2736 /*
2737 * Uniwill P53
2738 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2739  */
2740 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2741         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2742
2743         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2744         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2745         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2746         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2747         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2748         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2749         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2750         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2751         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2752         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2753         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2754         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2755
2756         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2757         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2758         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2759         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2760         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2761         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2762
2763         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2764         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2765
2766         { }
2767 };
2768
2769 static struct hda_verb alc880_beep_init_verbs[] = {
2770         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2771         { }
2772 };
2773
2774 /* auto-toggle front mic */
2775 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2776 {
2777         unsigned int present;
2778         unsigned char bits;
2779
2780         present = snd_hda_codec_read(codec, 0x18, 0,
2781                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
2782         bits = present ? HDA_AMP_MUTE : 0;
2783         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2784 }
2785
2786 static void alc880_uniwill_setup(struct hda_codec *codec)
2787 {
2788         struct alc_spec *spec = codec->spec;
2789
2790         spec->autocfg.hp_pins[0] = 0x14;
2791         spec->autocfg.speaker_pins[0] = 0x15;
2792         spec->autocfg.speaker_pins[0] = 0x16;
2793 }
2794
2795 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2796 {
2797         alc_automute_amp(codec);
2798         alc880_uniwill_mic_automute(codec);
2799 }
2800
2801 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2802                                        unsigned int res)
2803 {
2804         /* Looks like the unsol event is incompatible with the standard
2805          * definition.  4bit tag is placed at 28 bit!
2806          */
2807         switch (res >> 28) {
2808         case ALC880_MIC_EVENT:
2809                 alc880_uniwill_mic_automute(codec);
2810                 break;
2811         default:
2812                 alc_automute_amp_unsol_event(codec, res);
2813                 break;
2814         }
2815 }
2816
2817 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2818 {
2819         struct alc_spec *spec = codec->spec;
2820
2821         spec->autocfg.hp_pins[0] = 0x14;
2822         spec->autocfg.speaker_pins[0] = 0x15;
2823 }
2824
2825 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2826 {
2827         unsigned int present;
2828
2829         present = snd_hda_codec_read(codec, 0x21, 0,
2830                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2831         present &= HDA_AMP_VOLMASK;
2832         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2833                                  HDA_AMP_VOLMASK, present);
2834         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2835                                  HDA_AMP_VOLMASK, present);
2836 }
2837
2838 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2839                                            unsigned int res)
2840 {
2841         /* Looks like the unsol event is incompatible with the standard
2842          * definition.  4bit tag is placed at 28 bit!
2843          */
2844         if ((res >> 28) == ALC880_DCVOL_EVENT)
2845                 alc880_uniwill_p53_dcvol_automute(codec);
2846         else
2847                 alc_automute_amp_unsol_event(codec, res);
2848 }
2849
2850 /*
2851  * F1734 pin configuration:
2852  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2853  */
2854 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2855         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2856         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2857         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2858         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2859         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2860
2861         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2862         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2863         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2864         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2865
2866         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2867         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2868         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2869         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2870         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2871         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2872         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2873         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2874         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2875
2876         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
2877         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
2878
2879         { }
2880 };
2881
2882 /*
2883  * ASUS pin configuration:
2884  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
2885  */
2886 static struct hda_verb alc880_pin_asus_init_verbs[] = {
2887         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2888         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2889         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2890         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2891
2892         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2893         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2894         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2895         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2896         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2897         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2898         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2899         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2900
2901         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2902         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2903         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2904         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2905         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2906         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2907         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2908         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2909         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2910
2911         { }
2912 };
2913
2914 /* Enable GPIO mask and set output */
2915 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
2916 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
2917 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
2918
2919 /* Clevo m520g init */
2920 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
2921         /* headphone output */
2922         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
2923         /* line-out */
2924         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2925         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2926         /* Line-in */
2927         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2928         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2929         /* CD */
2930         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2931         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2932         /* Mic1 (rear panel) */
2933         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2934         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2935         /* Mic2 (front panel) */
2936         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2937         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2938         /* headphone */
2939         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2940         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2941         /* change to EAPD mode */
2942         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2943         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2944
2945         { }
2946 };
2947
2948 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
2949         /* change to EAPD mode */
2950         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2951         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
2952
2953         /* Headphone output */
2954         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2955         /* Front output*/
2956         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2957         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
2958
2959         /* Line In pin widget for input */
2960         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2961         /* CD pin widget for input */
2962         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2963         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2964         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2965
2966         /* change to EAPD mode */
2967         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
2968         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
2969
2970         { }
2971 };
2972
2973 /*
2974  * LG m1 express dual
2975  *
2976  * Pin assignment:
2977  *   Rear Line-In/Out (blue): 0x14
2978  *   Build-in Mic-In: 0x15
2979  *   Speaker-out: 0x17
2980  *   HP-Out (green): 0x1b
2981  *   Mic-In/Out (red): 0x19
2982  *   SPDIF-Out: 0x1e
2983  */
2984
2985 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
2986 static hda_nid_t alc880_lg_dac_nids[3] = {
2987         0x05, 0x02, 0x03
2988 };
2989
2990 /* seems analog CD is not working */
2991 static struct hda_input_mux alc880_lg_capture_source = {
2992         .num_items = 3,
2993         .items = {
2994                 { "Mic", 0x1 },
2995                 { "Line", 0x5 },
2996                 { "Internal Mic", 0x6 },
2997         },
2998 };
2999
3000 /* 2,4,6 channel modes */
3001 static struct hda_verb alc880_lg_ch2_init[] = {
3002         /* set line-in and mic-in to input */
3003         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3004         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3005         { }
3006 };
3007
3008 static struct hda_verb alc880_lg_ch4_init[] = {
3009         /* set line-in to out and mic-in to input */
3010         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3011         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3012         { }
3013 };
3014
3015 static struct hda_verb alc880_lg_ch6_init[] = {
3016         /* set line-in and mic-in to output */
3017         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3018         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3019         { }
3020 };
3021
3022 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3023         { 2, alc880_lg_ch2_init },
3024         { 4, alc880_lg_ch4_init },
3025         { 6, alc880_lg_ch6_init },
3026 };
3027
3028 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3029         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3030         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3031         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3032         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3033         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3034         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3035         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3036         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3038         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3039         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3040         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3041         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3042         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3043         {
3044                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3045                 .name = "Channel Mode",
3046                 .info = alc_ch_mode_info,
3047                 .get = alc_ch_mode_get,
3048                 .put = alc_ch_mode_put,
3049         },
3050         { } /* end */
3051 };
3052
3053 static struct hda_verb alc880_lg_init_verbs[] = {
3054         /* set capture source to mic-in */
3055         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3056         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3057         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3058         /* mute all amp mixer inputs */
3059         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3060         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3061         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3062         /* line-in to input */
3063         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3064         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3065         /* built-in mic */
3066         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3067         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3068         /* speaker-out */
3069         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3070         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3071         /* mic-in to input */
3072         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3073         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3074         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3075         /* HP-out */
3076         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3077         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3078         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3079         /* jack sense */
3080         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3081         { }
3082 };
3083
3084 /* toggle speaker-output according to the hp-jack state */
3085 static void alc880_lg_setup(struct hda_codec *codec)
3086 {
3087         struct alc_spec *spec = codec->spec;
3088
3089         spec->autocfg.hp_pins[0] = 0x1b;
3090         spec->autocfg.speaker_pins[0] = 0x17;
3091 }
3092
3093 /*
3094  * LG LW20
3095  *
3096  * Pin assignment:
3097  *   Speaker-out: 0x14
3098  *   Mic-In: 0x18
3099  *   Built-in Mic-In: 0x19
3100  *   Line-In: 0x1b
3101  *   HP-Out: 0x1a
3102  *   SPDIF-Out: 0x1e
3103  */
3104
3105 static struct hda_input_mux alc880_lg_lw_capture_source = {
3106         .num_items = 3,
3107         .items = {
3108                 { "Mic", 0x0 },
3109                 { "Internal Mic", 0x1 },
3110                 { "Line In", 0x2 },
3111         },
3112 };
3113
3114 #define alc880_lg_lw_modes alc880_threestack_modes
3115
3116 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3117         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3118         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3119         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3120         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3121         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3122         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3123         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3124         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3125         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3126         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3127         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3128         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3129         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3130         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3131         {
3132                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3133                 .name = "Channel Mode",
3134                 .info = alc_ch_mode_info,
3135                 .get = alc_ch_mode_get,
3136                 .put = alc_ch_mode_put,
3137         },
3138         { } /* end */
3139 };
3140
3141 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3142         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3143         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3144         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3145
3146         /* set capture source to mic-in */
3147         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3148         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3149         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3150         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3151         /* speaker-out */
3152         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3153         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3154         /* HP-out */
3155         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3156         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3157         /* mic-in to input */
3158         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3159         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3160         /* built-in mic */
3161         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3162         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3163         /* jack sense */
3164         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3165         { }
3166 };
3167
3168 /* toggle speaker-output according to the hp-jack state */
3169 static void alc880_lg_lw_setup(struct hda_codec *codec)
3170 {
3171         struct alc_spec *spec = codec->spec;
3172
3173         spec->autocfg.hp_pins[0] = 0x1b;
3174         spec->autocfg.speaker_pins[0] = 0x14;
3175 }
3176
3177 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3178         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3179         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3180         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3181         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3182         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3183         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3184         { } /* end */
3185 };
3186
3187 static struct hda_input_mux alc880_medion_rim_capture_source = {
3188         .num_items = 2,
3189         .items = {
3190                 { "Mic", 0x0 },
3191                 { "Internal Mic", 0x1 },
3192         },
3193 };
3194
3195 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3196         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3197
3198         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3199         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3200
3201         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3202         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3203         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3204         /* Mic2 (as headphone out) for HP output */
3205         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3206         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3207         /* Internal Speaker */
3208         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3209         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3210
3211         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3212         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3213
3214         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3215         { }
3216 };
3217
3218 /* toggle speaker-output according to the hp-jack state */
3219 static void alc880_medion_rim_automute(struct hda_codec *codec)
3220 {
3221         struct alc_spec *spec = codec->spec;
3222         alc_automute_amp(codec);
3223         /* toggle EAPD */
3224         if (spec->jack_present)
3225                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3226         else
3227                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3228 }
3229
3230 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3231                                           unsigned int res)
3232 {
3233         /* Looks like the unsol event is incompatible with the standard
3234          * definition.  4bit tag is placed at 28 bit!
3235          */
3236         if ((res >> 28) == ALC880_HP_EVENT)
3237                 alc880_medion_rim_automute(codec);
3238 }
3239
3240 static void alc880_medion_rim_setup(struct hda_codec *codec)
3241 {
3242         struct alc_spec *spec = codec->spec;
3243
3244         spec->autocfg.hp_pins[0] = 0x14;
3245         spec->autocfg.speaker_pins[0] = 0x1b;
3246 }
3247
3248 #ifdef CONFIG_SND_HDA_POWER_SAVE
3249 static struct hda_amp_list alc880_loopbacks[] = {
3250         { 0x0b, HDA_INPUT, 0 },
3251         { 0x0b, HDA_INPUT, 1 },
3252         { 0x0b, HDA_INPUT, 2 },
3253         { 0x0b, HDA_INPUT, 3 },
3254         { 0x0b, HDA_INPUT, 4 },
3255         { } /* end */
3256 };
3257
3258 static struct hda_amp_list alc880_lg_loopbacks[] = {
3259         { 0x0b, HDA_INPUT, 1 },
3260         { 0x0b, HDA_INPUT, 6 },
3261         { 0x0b, HDA_INPUT, 7 },
3262         { } /* end */
3263 };
3264 #endif
3265
3266 /*
3267  * Common callbacks
3268  */
3269
3270 static int alc_init(struct hda_codec *codec)
3271 {
3272         struct alc_spec *spec = codec->spec;
3273         unsigned int i;
3274
3275         alc_fix_pll(codec);
3276         alc_auto_init_amp(codec, spec->init_amp);
3277
3278         for (i = 0; i < spec->num_init_verbs; i++)
3279                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3280
3281         if (spec->init_hook)
3282                 spec->init_hook(codec);
3283
3284         return 0;
3285 }
3286
3287 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3288 {
3289         struct alc_spec *spec = codec->spec;
3290
3291         if (spec->unsol_event)
3292                 spec->unsol_event(codec, res);
3293 }
3294
3295 #ifdef CONFIG_SND_HDA_POWER_SAVE
3296 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3297 {
3298         struct alc_spec *spec = codec->spec;
3299         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3300 }
3301 #endif
3302
3303 /*
3304  * Analog playback callbacks
3305  */
3306 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3307                                     struct hda_codec *codec,
3308                                     struct snd_pcm_substream *substream)
3309 {
3310         struct alc_spec *spec = codec->spec;
3311         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3312                                              hinfo);
3313 }
3314
3315 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3316                                        struct hda_codec *codec,
3317                                        unsigned int stream_tag,
3318                                        unsigned int format,
3319                                        struct snd_pcm_substream *substream)
3320 {
3321         struct alc_spec *spec = codec->spec;
3322         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3323                                                 stream_tag, format, substream);
3324 }
3325
3326 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3327                                        struct hda_codec *codec,
3328                                        struct snd_pcm_substream *substream)
3329 {
3330         struct alc_spec *spec = codec->spec;
3331         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3332 }
3333
3334 /*
3335  * Digital out
3336  */
3337 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3338                                         struct hda_codec *codec,
3339                                         struct snd_pcm_substream *substream)
3340 {
3341         struct alc_spec *spec = codec->spec;
3342         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3343 }
3344
3345 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3346                                            struct hda_codec *codec,
3347                                            unsigned int stream_tag,
3348                                            unsigned int format,
3349                                            struct snd_pcm_substream *substream)
3350 {
3351         struct alc_spec *spec = codec->spec;
3352         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3353                                              stream_tag, format, substream);
3354 }
3355
3356 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3357                                            struct hda_codec *codec,
3358                                            struct snd_pcm_substream *substream)
3359 {
3360         struct alc_spec *spec = codec->spec;
3361         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3362 }
3363
3364 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3365                                          struct hda_codec *codec,
3366                                          struct snd_pcm_substream *substream)
3367 {
3368         struct alc_spec *spec = codec->spec;
3369         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3370 }
3371
3372 /*
3373  * Analog capture
3374  */
3375 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3376                                       struct hda_codec *codec,
3377                                       unsigned int stream_tag,
3378                                       unsigned int format,
3379                                       struct snd_pcm_substream *substream)
3380 {
3381         struct alc_spec *spec = codec->spec;
3382
3383         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3384                                    stream_tag, 0, format);
3385         return 0;
3386 }
3387
3388 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3389                                       struct hda_codec *codec,
3390                                       struct snd_pcm_substream *substream)
3391 {
3392         struct alc_spec *spec = codec->spec;
3393
3394         snd_hda_codec_cleanup_stream(codec,
3395                                      spec->adc_nids[substream->number + 1]);
3396         return 0;
3397 }
3398
3399
3400 /*
3401  */
3402 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3403         .substreams = 1,
3404         .channels_min = 2,
3405         .channels_max = 8,
3406         /* NID is set in alc_build_pcms */
3407         .ops = {
3408                 .open = alc880_playback_pcm_open,
3409                 .prepare = alc880_playback_pcm_prepare,
3410                 .cleanup = alc880_playback_pcm_cleanup
3411         },
3412 };
3413
3414 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3415         .substreams = 1,
3416         .channels_min = 2,
3417         .channels_max = 2,
3418         /* NID is set in alc_build_pcms */
3419 };
3420
3421 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3422         .substreams = 1,
3423         .channels_min = 2,
3424         .channels_max = 2,
3425         /* NID is set in alc_build_pcms */
3426 };
3427
3428 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3429         .substreams = 2, /* can be overridden */
3430         .channels_min = 2,
3431         .channels_max = 2,
3432         /* NID is set in alc_build_pcms */
3433         .ops = {
3434                 .prepare = alc880_alt_capture_pcm_prepare,
3435                 .cleanup = alc880_alt_capture_pcm_cleanup
3436         },
3437 };
3438
3439 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3440         .substreams = 1,
3441         .channels_min = 2,
3442         .channels_max = 2,
3443         /* NID is set in alc_build_pcms */
3444         .ops = {
3445                 .open = alc880_dig_playback_pcm_open,
3446                 .close = alc880_dig_playback_pcm_close,
3447                 .prepare = alc880_dig_playback_pcm_prepare,
3448                 .cleanup = alc880_dig_playback_pcm_cleanup
3449         },
3450 };
3451
3452 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3453         .substreams = 1,
3454         .channels_min = 2,
3455         .channels_max = 2,
3456         /* NID is set in alc_build_pcms */
3457 };
3458
3459 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3460 static struct hda_pcm_stream alc_pcm_null_stream = {
3461         .substreams = 0,
3462         .channels_min = 0,
3463         .channels_max = 0,
3464 };
3465
3466 static int alc_build_pcms(struct hda_codec *codec)
3467 {
3468         struct alc_spec *spec = codec->spec;
3469         struct hda_pcm *info = spec->pcm_rec;
3470         int i;
3471
3472         codec->num_pcms = 1;
3473         codec->pcm_info = info;
3474
3475         if (spec->no_analog)
3476                 goto skip_analog;
3477
3478         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3479                  "%s Analog", codec->chip_name);
3480         info->name = spec->stream_name_analog;
3481
3482         if (spec->stream_analog_playback) {
3483                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3484                         return -EINVAL;
3485                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3486                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3487         }
3488         if (spec->stream_analog_capture) {
3489                 if (snd_BUG_ON(!spec->adc_nids))
3490                         return -EINVAL;
3491                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3492                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3493         }
3494
3495         if (spec->channel_mode) {
3496                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3497                 for (i = 0; i < spec->num_channel_mode; i++) {
3498                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3499                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3500                         }
3501                 }
3502         }
3503
3504  skip_analog:
3505         /* SPDIF for stream index #1 */
3506         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3507                 snprintf(spec->stream_name_digital,
3508                          sizeof(spec->stream_name_digital),
3509                          "%s Digital", codec->chip_name);
3510                 codec->num_pcms = 2;
3511                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3512                 info = spec->pcm_rec + 1;
3513                 info->name = spec->stream_name_digital;
3514                 if (spec->dig_out_type)
3515                         info->pcm_type = spec->dig_out_type;
3516                 else
3517                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3518                 if (spec->multiout.dig_out_nid &&
3519                     spec->stream_digital_playback) {
3520                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3521                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3522                 }
3523                 if (spec->dig_in_nid &&
3524                     spec->stream_digital_capture) {
3525                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3526                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3527                 }
3528                 /* FIXME: do we need this for all Realtek codec models? */
3529                 codec->spdif_status_reset = 1;
3530         }
3531
3532         if (spec->no_analog)
3533                 return 0;
3534
3535         /* If the use of more than one ADC is requested for the current
3536          * model, configure a second analog capture-only PCM.
3537          */
3538         /* Additional Analaog capture for index #2 */
3539         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3540             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3541                 codec->num_pcms = 3;
3542                 info = spec->pcm_rec + 2;
3543                 info->name = spec->stream_name_analog;
3544                 if (spec->alt_dac_nid) {
3545                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3546                                 *spec->stream_analog_alt_playback;
3547                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3548                                 spec->alt_dac_nid;
3549                 } else {
3550                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3551                                 alc_pcm_null_stream;
3552                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3553                 }
3554                 if (spec->num_adc_nids > 1) {
3555                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3556                                 *spec->stream_analog_alt_capture;
3557                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3558                                 spec->adc_nids[1];
3559                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3560                                 spec->num_adc_nids - 1;
3561                 } else {
3562                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3563                                 alc_pcm_null_stream;
3564                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3565                 }
3566         }
3567
3568         return 0;
3569 }
3570
3571 static void alc_free_kctls(struct hda_codec *codec)
3572 {
3573         struct alc_spec *spec = codec->spec;
3574
3575         if (spec->kctls.list) {
3576                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3577                 int i;
3578                 for (i = 0; i < spec->kctls.used; i++)
3579                         kfree(kctl[i].name);
3580         }
3581         snd_array_free(&spec->kctls);
3582 }
3583
3584 static void alc_free(struct hda_codec *codec)
3585 {
3586         struct alc_spec *spec = codec->spec;
3587
3588         if (!spec)
3589                 return;
3590
3591         alc_free_kctls(codec);
3592         kfree(spec);
3593         snd_hda_detach_beep_device(codec);
3594 }
3595
3596 #ifdef SND_HDA_NEEDS_RESUME
3597 static int alc_resume(struct hda_codec *codec)
3598 {
3599         codec->patch_ops.init(codec);
3600         snd_hda_codec_resume_amp(codec);
3601         snd_hda_codec_resume_cache(codec);
3602         return 0;
3603 }
3604 #endif
3605
3606 /*
3607  */
3608 static struct hda_codec_ops alc_patch_ops = {
3609         .build_controls = alc_build_controls,
3610         .build_pcms = alc_build_pcms,
3611         .init = alc_init,
3612         .free = alc_free,
3613         .unsol_event = alc_unsol_event,
3614 #ifdef SND_HDA_NEEDS_RESUME
3615         .resume = alc_resume,
3616 #endif
3617 #ifdef CONFIG_SND_HDA_POWER_SAVE
3618         .check_power_status = alc_check_power_status,
3619 #endif
3620 };
3621
3622
3623 /*
3624  * Test configuration for debugging
3625  *
3626  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3627  * enum controls.
3628  */
3629 #ifdef CONFIG_SND_DEBUG
3630 static hda_nid_t alc880_test_dac_nids[4] = {
3631         0x02, 0x03, 0x04, 0x05
3632 };
3633
3634 static struct hda_input_mux alc880_test_capture_source = {
3635         .num_items = 7,
3636         .items = {
3637                 { "In-1", 0x0 },
3638                 { "In-2", 0x1 },
3639                 { "In-3", 0x2 },
3640                 { "In-4", 0x3 },
3641                 { "CD", 0x4 },
3642                 { "Front", 0x5 },
3643                 { "Surround", 0x6 },
3644         },
3645 };
3646
3647 static struct hda_channel_mode alc880_test_modes[4] = {
3648         { 2, NULL },
3649         { 4, NULL },
3650         { 6, NULL },
3651         { 8, NULL },
3652 };
3653
3654 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3655                                  struct snd_ctl_elem_info *uinfo)
3656 {
3657         static char *texts[] = {
3658                 "N/A", "Line Out", "HP Out",
3659                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3660         };
3661         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3662         uinfo->count = 1;
3663         uinfo->value.enumerated.items = 8;
3664         if (uinfo->value.enumerated.item >= 8)
3665                 uinfo->value.enumerated.item = 7;
3666         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3667         return 0;
3668 }
3669
3670 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3671                                 struct snd_ctl_elem_value *ucontrol)
3672 {
3673         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3674         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3675         unsigned int pin_ctl, item = 0;
3676
3677         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3678                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3679         if (pin_ctl & AC_PINCTL_OUT_EN) {
3680                 if (pin_ctl & AC_PINCTL_HP_EN)
3681                         item = 2;
3682                 else
3683                         item = 1;
3684         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3685                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3686                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3687                 case AC_PINCTL_VREF_50:  item = 4; break;
3688                 case AC_PINCTL_VREF_GRD: item = 5; break;
3689                 case AC_PINCTL_VREF_80:  item = 6; break;
3690                 case AC_PINCTL_VREF_100: item = 7; break;
3691                 }
3692         }
3693         ucontrol->value.enumerated.item[0] = item;
3694         return 0;
3695 }
3696
3697 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3698                                 struct snd_ctl_elem_value *ucontrol)
3699 {
3700         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3701         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3702         static unsigned int ctls[] = {
3703                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3704                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3705                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3706                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3707                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3708                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3709         };
3710         unsigned int old_ctl, new_ctl;
3711
3712         old_ctl = snd_hda_codec_read(codec, nid, 0,
3713                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3714         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3715         if (old_ctl != new_ctl) {
3716                 int val;
3717                 snd_hda_codec_write_cache(codec, nid, 0,
3718                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3719                                           new_ctl);
3720                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3721                         HDA_AMP_MUTE : 0;
3722                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3723                                          HDA_AMP_MUTE, val);
3724                 return 1;
3725         }
3726         return 0;
3727 }
3728
3729 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3730                                  struct snd_ctl_elem_info *uinfo)
3731 {
3732         static char *texts[] = {
3733                 "Front", "Surround", "CLFE", "Side"
3734         };
3735         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3736         uinfo->count = 1;
3737         uinfo->value.enumerated.items = 4;
3738         if (uinfo->value.enumerated.item >= 4)
3739                 uinfo->value.enumerated.item = 3;
3740         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3741         return 0;
3742 }
3743
3744 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3745                                 struct snd_ctl_elem_value *ucontrol)
3746 {
3747         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3748         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3749         unsigned int sel;
3750
3751         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3752         ucontrol->value.enumerated.item[0] = sel & 3;
3753         return 0;
3754 }
3755
3756 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3757                                 struct snd_ctl_elem_value *ucontrol)
3758 {
3759         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3760         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3761         unsigned int sel;
3762
3763         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3764         if (ucontrol->value.enumerated.item[0] != sel) {
3765                 sel = ucontrol->value.enumerated.item[0] & 3;
3766                 snd_hda_codec_write_cache(codec, nid, 0,
3767                                           AC_VERB_SET_CONNECT_SEL, sel);
3768                 return 1;
3769         }
3770         return 0;
3771 }
3772
3773 #define PIN_CTL_TEST(xname,nid) {                       \
3774                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3775                         .name = xname,                 \
3776                         .info = alc_test_pin_ctl_info, \
3777                         .get = alc_test_pin_ctl_get,   \
3778                         .put = alc_test_pin_ctl_put,   \
3779                         .private_value = nid           \
3780                         }
3781
3782 #define PIN_SRC_TEST(xname,nid) {                       \
3783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3784                         .name = xname,                 \
3785                         .info = alc_test_pin_src_info, \
3786                         .get = alc_test_pin_src_get,   \
3787                         .put = alc_test_pin_src_put,   \
3788                         .private_value = nid           \
3789                         }
3790
3791 static struct snd_kcontrol_new alc880_test_mixer[] = {
3792         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3793         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3794         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3795         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3796         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3797         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3798         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3799         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3800         PIN_CTL_TEST("Front Pin Mode", 0x14),
3801         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3802         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3803         PIN_CTL_TEST("Side Pin Mode", 0x17),
3804         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3805         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3806         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3807         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3808         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3809         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3810         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3811         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3812         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3813         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3814         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3815         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3816         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3817         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3818         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3819         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3820         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3821         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3822         {
3823                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3824                 .name = "Channel Mode",
3825                 .info = alc_ch_mode_info,
3826                 .get = alc_ch_mode_get,
3827                 .put = alc_ch_mode_put,
3828         },
3829         { } /* end */
3830 };
3831
3832 static struct hda_verb alc880_test_init_verbs[] = {
3833         /* Unmute inputs of 0x0c - 0x0f */
3834         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3835         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3836         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3837         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3838         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3839         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3840         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3841         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3842         /* Vol output for 0x0c-0x0f */
3843         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3844         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3845         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3846         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
3847         /* Set output pins 0x14-0x17 */
3848         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3849         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3850         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3851         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3852         /* Unmute output pins 0x14-0x17 */
3853         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3855         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3856         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3857         /* Set input pins 0x18-0x1c */
3858         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3859         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3860         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3861         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3862         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3863         /* Mute input pins 0x18-0x1b */
3864         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3865         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3866         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3867         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3868         /* ADC set up */
3869         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3870         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
3871         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3872         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
3873         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3874         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
3875         /* Analog input/passthru */
3876         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
3877         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
3878         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
3879         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
3880         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
3881         { }
3882 };
3883 #endif
3884
3885 /*
3886  */
3887
3888 static const char *alc880_models[ALC880_MODEL_LAST] = {
3889         [ALC880_3ST]            = "3stack",
3890         [ALC880_TCL_S700]       = "tcl",
3891         [ALC880_3ST_DIG]        = "3stack-digout",
3892         [ALC880_CLEVO]          = "clevo",
3893         [ALC880_5ST]            = "5stack",
3894         [ALC880_5ST_DIG]        = "5stack-digout",
3895         [ALC880_W810]           = "w810",
3896         [ALC880_Z71V]           = "z71v",
3897         [ALC880_6ST]            = "6stack",
3898         [ALC880_6ST_DIG]        = "6stack-digout",
3899         [ALC880_ASUS]           = "asus",
3900         [ALC880_ASUS_W1V]       = "asus-w1v",
3901         [ALC880_ASUS_DIG]       = "asus-dig",
3902         [ALC880_ASUS_DIG2]      = "asus-dig2",
3903         [ALC880_UNIWILL_DIG]    = "uniwill",
3904         [ALC880_UNIWILL_P53]    = "uniwill-p53",
3905         [ALC880_FUJITSU]        = "fujitsu",
3906         [ALC880_F1734]          = "F1734",
3907         [ALC880_LG]             = "lg",
3908         [ALC880_LG_LW]          = "lg-lw",
3909         [ALC880_MEDION_RIM]     = "medion",
3910 #ifdef CONFIG_SND_DEBUG
3911         [ALC880_TEST]           = "test",
3912 #endif
3913         [ALC880_AUTO]           = "auto",
3914 };
3915
3916 static struct snd_pci_quirk alc880_cfg_tbl[] = {
3917         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
3918         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
3919         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
3920         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
3921         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
3922         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
3923         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
3924         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
3925         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
3926         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
3927         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
3928         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
3929         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
3930         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
3931         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
3932         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
3933         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
3934         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
3935         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
3936         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
3937         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
3938         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
3939         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
3940         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
3941         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
3942         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
3943         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
3944         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
3945         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
3946         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
3947         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
3948         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
3949         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
3950         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
3951         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
3952         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
3953         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
3954         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
3955         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
3956         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
3957         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
3958         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
3959         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
3960         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
3961         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
3962         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
3963         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
3964         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
3965         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
3966         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
3967         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
3968         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
3969         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
3970         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
3971         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
3972         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
3973         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
3974         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
3975         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
3976         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
3977         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
3978         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
3979         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
3980         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
3981         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
3982         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
3983         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
3984         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
3985         /* default Intel */
3986         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
3987         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
3988         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
3989         {}
3990 };
3991
3992 /*
3993  * ALC880 codec presets
3994  */
3995 static struct alc_config_preset alc880_presets[] = {
3996         [ALC880_3ST] = {
3997                 .mixers = { alc880_three_stack_mixer },
3998                 .init_verbs = { alc880_volume_init_verbs,
3999                                 alc880_pin_3stack_init_verbs },
4000                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4001                 .dac_nids = alc880_dac_nids,
4002                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4003                 .channel_mode = alc880_threestack_modes,
4004                 .need_dac_fix = 1,
4005                 .input_mux = &alc880_capture_source,
4006         },
4007         [ALC880_3ST_DIG] = {
4008                 .mixers = { alc880_three_stack_mixer },
4009                 .init_verbs = { alc880_volume_init_verbs,
4010                                 alc880_pin_3stack_init_verbs },
4011                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4012                 .dac_nids = alc880_dac_nids,
4013                 .dig_out_nid = ALC880_DIGOUT_NID,
4014                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4015                 .channel_mode = alc880_threestack_modes,
4016                 .need_dac_fix = 1,
4017                 .input_mux = &alc880_capture_source,
4018         },
4019         [ALC880_TCL_S700] = {
4020                 .mixers = { alc880_tcl_s700_mixer },
4021                 .init_verbs = { alc880_volume_init_verbs,
4022                                 alc880_pin_tcl_S700_init_verbs,
4023                                 alc880_gpio2_init_verbs },
4024                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4025                 .dac_nids = alc880_dac_nids,
4026                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4027                 .num_adc_nids = 1, /* single ADC */
4028                 .hp_nid = 0x03,
4029                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4030                 .channel_mode = alc880_2_jack_modes,
4031                 .input_mux = &alc880_capture_source,
4032         },
4033         [ALC880_5ST] = {
4034                 .mixers = { alc880_three_stack_mixer,
4035                             alc880_five_stack_mixer},
4036                 .init_verbs = { alc880_volume_init_verbs,
4037                                 alc880_pin_5stack_init_verbs },
4038                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4039                 .dac_nids = alc880_dac_nids,
4040                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4041                 .channel_mode = alc880_fivestack_modes,
4042                 .input_mux = &alc880_capture_source,
4043         },
4044         [ALC880_5ST_DIG] = {
4045                 .mixers = { alc880_three_stack_mixer,
4046                             alc880_five_stack_mixer },
4047                 .init_verbs = { alc880_volume_init_verbs,
4048                                 alc880_pin_5stack_init_verbs },
4049                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4050                 .dac_nids = alc880_dac_nids,
4051                 .dig_out_nid = ALC880_DIGOUT_NID,
4052                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4053                 .channel_mode = alc880_fivestack_modes,
4054                 .input_mux = &alc880_capture_source,
4055         },
4056         [ALC880_6ST] = {
4057                 .mixers = { alc880_six_stack_mixer },
4058                 .init_verbs = { alc880_volume_init_verbs,
4059                                 alc880_pin_6stack_init_verbs },
4060                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4061                 .dac_nids = alc880_6st_dac_nids,
4062                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4063                 .channel_mode = alc880_sixstack_modes,
4064                 .input_mux = &alc880_6stack_capture_source,
4065         },
4066         [ALC880_6ST_DIG] = {
4067                 .mixers = { alc880_six_stack_mixer },
4068                 .init_verbs = { alc880_volume_init_verbs,
4069                                 alc880_pin_6stack_init_verbs },
4070                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4071                 .dac_nids = alc880_6st_dac_nids,
4072                 .dig_out_nid = ALC880_DIGOUT_NID,
4073                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4074                 .channel_mode = alc880_sixstack_modes,
4075                 .input_mux = &alc880_6stack_capture_source,
4076         },
4077         [ALC880_W810] = {
4078                 .mixers = { alc880_w810_base_mixer },
4079                 .init_verbs = { alc880_volume_init_verbs,
4080                                 alc880_pin_w810_init_verbs,
4081                                 alc880_gpio2_init_verbs },
4082                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4083                 .dac_nids = alc880_w810_dac_nids,
4084                 .dig_out_nid = ALC880_DIGOUT_NID,
4085                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4086                 .channel_mode = alc880_w810_modes,
4087                 .input_mux = &alc880_capture_source,
4088         },
4089         [ALC880_Z71V] = {
4090                 .mixers = { alc880_z71v_mixer },
4091                 .init_verbs = { alc880_volume_init_verbs,
4092                                 alc880_pin_z71v_init_verbs },
4093                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4094                 .dac_nids = alc880_z71v_dac_nids,
4095                 .dig_out_nid = ALC880_DIGOUT_NID,
4096                 .hp_nid = 0x03,
4097                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4098                 .channel_mode = alc880_2_jack_modes,
4099                 .input_mux = &alc880_capture_source,
4100         },
4101         [ALC880_F1734] = {
4102                 .mixers = { alc880_f1734_mixer },
4103                 .init_verbs = { alc880_volume_init_verbs,
4104                                 alc880_pin_f1734_init_verbs },
4105                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4106                 .dac_nids = alc880_f1734_dac_nids,
4107                 .hp_nid = 0x02,
4108                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4109                 .channel_mode = alc880_2_jack_modes,
4110                 .input_mux = &alc880_f1734_capture_source,
4111                 .unsol_event = alc880_uniwill_p53_unsol_event,
4112                 .setup = alc880_uniwill_p53_setup,
4113                 .init_hook = alc_automute_amp,
4114         },
4115         [ALC880_ASUS] = {
4116                 .mixers = { alc880_asus_mixer },
4117                 .init_verbs = { alc880_volume_init_verbs,
4118                                 alc880_pin_asus_init_verbs,
4119                                 alc880_gpio1_init_verbs },
4120                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4121                 .dac_nids = alc880_asus_dac_nids,
4122                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4123                 .channel_mode = alc880_asus_modes,
4124                 .need_dac_fix = 1,
4125                 .input_mux = &alc880_capture_source,
4126         },
4127         [ALC880_ASUS_DIG] = {
4128                 .mixers = { alc880_asus_mixer },
4129                 .init_verbs = { alc880_volume_init_verbs,
4130                                 alc880_pin_asus_init_verbs,
4131                                 alc880_gpio1_init_verbs },
4132                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4133                 .dac_nids = alc880_asus_dac_nids,
4134                 .dig_out_nid = ALC880_DIGOUT_NID,
4135                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4136                 .channel_mode = alc880_asus_modes,
4137                 .need_dac_fix = 1,
4138                 .input_mux = &alc880_capture_source,
4139         },
4140         [ALC880_ASUS_DIG2] = {
4141                 .mixers = { alc880_asus_mixer },
4142                 .init_verbs = { alc880_volume_init_verbs,
4143                                 alc880_pin_asus_init_verbs,
4144                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4145                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4146                 .dac_nids = alc880_asus_dac_nids,
4147                 .dig_out_nid = ALC880_DIGOUT_NID,
4148                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4149                 .channel_mode = alc880_asus_modes,
4150                 .need_dac_fix = 1,
4151                 .input_mux = &alc880_capture_source,
4152         },
4153         [ALC880_ASUS_W1V] = {
4154                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4155                 .init_verbs = { alc880_volume_init_verbs,
4156                                 alc880_pin_asus_init_verbs,
4157                                 alc880_gpio1_init_verbs },
4158                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4159                 .dac_nids = alc880_asus_dac_nids,
4160                 .dig_out_nid = ALC880_DIGOUT_NID,
4161                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4162                 .channel_mode = alc880_asus_modes,
4163                 .need_dac_fix = 1,
4164                 .input_mux = &alc880_capture_source,
4165         },
4166         [ALC880_UNIWILL_DIG] = {
4167                 .mixers = { alc880_asus_mixer },
4168                 .init_verbs = { alc880_volume_init_verbs,
4169                                 alc880_pin_asus_init_verbs },
4170                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4171                 .dac_nids = alc880_asus_dac_nids,
4172                 .dig_out_nid = ALC880_DIGOUT_NID,
4173                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4174                 .channel_mode = alc880_asus_modes,
4175                 .need_dac_fix = 1,
4176                 .input_mux = &alc880_capture_source,
4177         },
4178         [ALC880_UNIWILL] = {
4179                 .mixers = { alc880_uniwill_mixer },
4180                 .init_verbs = { alc880_volume_init_verbs,
4181                                 alc880_uniwill_init_verbs },
4182                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4183                 .dac_nids = alc880_asus_dac_nids,
4184                 .dig_out_nid = ALC880_DIGOUT_NID,
4185                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4186                 .channel_mode = alc880_threestack_modes,
4187                 .need_dac_fix = 1,
4188                 .input_mux = &alc880_capture_source,
4189                 .unsol_event = alc880_uniwill_unsol_event,
4190                 .setup = alc880_uniwill_setup,
4191                 .init_hook = alc880_uniwill_init_hook,
4192         },
4193         [ALC880_UNIWILL_P53] = {
4194                 .mixers = { alc880_uniwill_p53_mixer },
4195                 .init_verbs = { alc880_volume_init_verbs,
4196                                 alc880_uniwill_p53_init_verbs },
4197                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4198                 .dac_nids = alc880_asus_dac_nids,
4199                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4200                 .channel_mode = alc880_threestack_modes,
4201                 .input_mux = &alc880_capture_source,
4202                 .unsol_event = alc880_uniwill_p53_unsol_event,
4203                 .setup = alc880_uniwill_p53_setup,
4204                 .init_hook = alc_automute_amp,
4205         },
4206         [ALC880_FUJITSU] = {
4207                 .mixers = { alc880_fujitsu_mixer },
4208                 .init_verbs = { alc880_volume_init_verbs,
4209                                 alc880_uniwill_p53_init_verbs,
4210                                 alc880_beep_init_verbs },
4211                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4212                 .dac_nids = alc880_dac_nids,
4213                 .dig_out_nid = ALC880_DIGOUT_NID,
4214                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4215                 .channel_mode = alc880_2_jack_modes,
4216                 .input_mux = &alc880_capture_source,
4217                 .unsol_event = alc880_uniwill_p53_unsol_event,
4218                 .setup = alc880_uniwill_p53_setup,
4219                 .init_hook = alc_automute_amp,
4220         },
4221         [ALC880_CLEVO] = {
4222                 .mixers = { alc880_three_stack_mixer },
4223                 .init_verbs = { alc880_volume_init_verbs,
4224                                 alc880_pin_clevo_init_verbs },
4225                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4226                 .dac_nids = alc880_dac_nids,
4227                 .hp_nid = 0x03,
4228                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4229                 .channel_mode = alc880_threestack_modes,
4230                 .need_dac_fix = 1,
4231                 .input_mux = &alc880_capture_source,
4232         },
4233         [ALC880_LG] = {
4234                 .mixers = { alc880_lg_mixer },
4235                 .init_verbs = { alc880_volume_init_verbs,
4236                                 alc880_lg_init_verbs },
4237                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4238                 .dac_nids = alc880_lg_dac_nids,
4239                 .dig_out_nid = ALC880_DIGOUT_NID,
4240                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4241                 .channel_mode = alc880_lg_ch_modes,
4242                 .need_dac_fix = 1,
4243                 .input_mux = &alc880_lg_capture_source,
4244                 .unsol_event = alc_automute_amp_unsol_event,
4245                 .setup = alc880_lg_setup,
4246                 .init_hook = alc_automute_amp,
4247 #ifdef CONFIG_SND_HDA_POWER_SAVE
4248                 .loopbacks = alc880_lg_loopbacks,
4249 #endif
4250         },
4251         [ALC880_LG_LW] = {
4252                 .mixers = { alc880_lg_lw_mixer },
4253                 .init_verbs = { alc880_volume_init_verbs,
4254                                 alc880_lg_lw_init_verbs },
4255                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4256                 .dac_nids = alc880_dac_nids,
4257                 .dig_out_nid = ALC880_DIGOUT_NID,
4258                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4259                 .channel_mode = alc880_lg_lw_modes,
4260                 .input_mux = &alc880_lg_lw_capture_source,
4261                 .unsol_event = alc_automute_amp_unsol_event,
4262                 .setup = alc880_lg_lw_setup,
4263                 .init_hook = alc_automute_amp,
4264         },
4265         [ALC880_MEDION_RIM] = {
4266                 .mixers = { alc880_medion_rim_mixer },
4267                 .init_verbs = { alc880_volume_init_verbs,
4268                                 alc880_medion_rim_init_verbs,
4269                                 alc_gpio2_init_verbs },
4270                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4271                 .dac_nids = alc880_dac_nids,
4272                 .dig_out_nid = ALC880_DIGOUT_NID,
4273                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4274                 .channel_mode = alc880_2_jack_modes,
4275                 .input_mux = &alc880_medion_rim_capture_source,
4276                 .unsol_event = alc880_medion_rim_unsol_event,
4277                 .setup = alc880_medion_rim_setup,
4278                 .init_hook = alc880_medion_rim_automute,
4279         },
4280 #ifdef CONFIG_SND_DEBUG
4281         [ALC880_TEST] = {
4282                 .mixers = { alc880_test_mixer },
4283                 .init_verbs = { alc880_test_init_verbs },
4284                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4285                 .dac_nids = alc880_test_dac_nids,
4286                 .dig_out_nid = ALC880_DIGOUT_NID,
4287                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4288                 .channel_mode = alc880_test_modes,
4289                 .input_mux = &alc880_test_capture_source,
4290         },
4291 #endif
4292 };
4293
4294 /*
4295  * Automatic parse of I/O pins from the BIOS configuration
4296  */
4297
4298 enum {
4299         ALC_CTL_WIDGET_VOL,
4300         ALC_CTL_WIDGET_MUTE,
4301         ALC_CTL_BIND_MUTE,
4302 };
4303 static struct snd_kcontrol_new alc880_control_templates[] = {
4304         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4305         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4306         HDA_BIND_MUTE(NULL, 0, 0, 0),
4307 };
4308
4309 /* add dynamic controls */
4310 static int add_control(struct alc_spec *spec, int type, const char *name,
4311                        unsigned long val)
4312 {
4313         struct snd_kcontrol_new *knew;
4314
4315         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4316         knew = snd_array_new(&spec->kctls);
4317         if (!knew)
4318                 return -ENOMEM;
4319         *knew = alc880_control_templates[type];
4320         knew->name = kstrdup(name, GFP_KERNEL);
4321         if (!knew->name)
4322                 return -ENOMEM;
4323         knew->private_value = val;
4324         return 0;
4325 }
4326
4327 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4328 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4329 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4330 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4331 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4332 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4333 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4334 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4335 #define ALC880_PIN_CD_NID               0x1c
4336
4337 /* fill in the dac_nids table from the parsed pin configuration */
4338 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4339                                      const struct auto_pin_cfg *cfg)
4340 {
4341         hda_nid_t nid;
4342         int assigned[4];
4343         int i, j;
4344
4345         memset(assigned, 0, sizeof(assigned));
4346         spec->multiout.dac_nids = spec->private_dac_nids;
4347
4348         /* check the pins hardwired to audio widget */
4349         for (i = 0; i < cfg->line_outs; i++) {
4350                 nid = cfg->line_out_pins[i];
4351                 if (alc880_is_fixed_pin(nid)) {
4352                         int idx = alc880_fixed_pin_idx(nid);
4353                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4354                         assigned[idx] = 1;
4355                 }
4356         }
4357         /* left pins can be connect to any audio widget */
4358         for (i = 0; i < cfg->line_outs; i++) {
4359                 nid = cfg->line_out_pins[i];
4360                 if (alc880_is_fixed_pin(nid))
4361                         continue;
4362                 /* search for an empty channel */
4363                 for (j = 0; j < cfg->line_outs; j++) {
4364                         if (!assigned[j]) {
4365                                 spec->multiout.dac_nids[i] =
4366                                         alc880_idx_to_dac(j);
4367                                 assigned[j] = 1;
4368                                 break;
4369                         }
4370                 }
4371         }
4372         spec->multiout.num_dacs = cfg->line_outs;
4373         return 0;
4374 }
4375
4376 /* add playback controls from the parsed DAC table */
4377 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4378                                              const struct auto_pin_cfg *cfg)
4379 {
4380         char name[32];
4381         static const char *chname[4] = {
4382                 "Front", "Surround", NULL /*CLFE*/, "Side"
4383         };
4384         hda_nid_t nid;
4385         int i, err;
4386
4387         for (i = 0; i < cfg->line_outs; i++) {
4388                 if (!spec->multiout.dac_nids[i])
4389                         continue;
4390                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4391                 if (i == 2) {
4392                         /* Center/LFE */
4393                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4394                                           "Center Playback Volume",
4395                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4396                                                               HDA_OUTPUT));
4397                         if (err < 0)
4398                                 return err;
4399                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
4400                                           "LFE Playback Volume",
4401                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4402                                                               HDA_OUTPUT));
4403                         if (err < 0)
4404                                 return err;
4405                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4406                                           "Center Playback Switch",
4407                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4408                                                               HDA_INPUT));
4409                         if (err < 0)
4410                                 return err;
4411                         err = add_control(spec, ALC_CTL_BIND_MUTE,
4412                                           "LFE Playback Switch",
4413                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4414                                                               HDA_INPUT));
4415                         if (err < 0)
4416                                 return err;
4417                 } else {
4418                         const char *pfx;
4419                         if (cfg->line_outs == 1 &&
4420                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4421                                 pfx = "Speaker";
4422                         else
4423                                 pfx = chname[i];
4424                         sprintf(name, "%s Playback Volume", pfx);
4425                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4426                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4427                                                               HDA_OUTPUT));
4428                         if (err < 0)
4429                                 return err;
4430                         sprintf(name, "%s Playback Switch", pfx);
4431                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4432                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4433                                                               HDA_INPUT));
4434                         if (err < 0)
4435                                 return err;
4436                 }
4437         }
4438         return 0;
4439 }
4440
4441 /* add playback controls for speaker and HP outputs */
4442 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4443                                         const char *pfx)
4444 {
4445         hda_nid_t nid;
4446         int err;
4447         char name[32];
4448
4449         if (!pin)
4450                 return 0;
4451
4452         if (alc880_is_fixed_pin(pin)) {
4453                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4454                 /* specify the DAC as the extra output */
4455                 if (!spec->multiout.hp_nid)
4456                         spec->multiout.hp_nid = nid;
4457                 else
4458                         spec->multiout.extra_out_nid[0] = nid;
4459                 /* control HP volume/switch on the output mixer amp */
4460                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4461                 sprintf(name, "%s Playback Volume", pfx);
4462                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4463                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4464                 if (err < 0)
4465                         return err;
4466                 sprintf(name, "%s Playback Switch", pfx);
4467                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
4468                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4469                 if (err < 0)
4470                         return err;
4471         } else if (alc880_is_multi_pin(pin)) {
4472                 /* set manual connection */
4473                 /* we have only a switch on HP-out PIN */
4474                 sprintf(name, "%s Playback Switch", pfx);
4475                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4476                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4477                 if (err < 0)
4478                         return err;
4479         }
4480         return 0;
4481 }
4482
4483 /* create input playback/capture controls for the given pin */
4484 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4485                             const char *ctlname,
4486                             int idx, hda_nid_t mix_nid)
4487 {
4488         char name[32];
4489         int err;
4490
4491         sprintf(name, "%s Playback Volume", ctlname);
4492         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
4493                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4494         if (err < 0)
4495                 return err;
4496         sprintf(name, "%s Playback Switch", ctlname);
4497         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
4498                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4499         if (err < 0)
4500                 return err;
4501         return 0;
4502 }
4503
4504 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4505 {
4506         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4507         return (pincap & AC_PINCAP_IN) != 0;
4508 }
4509
4510 /* create playback/capture controls for input pins */
4511 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4512                                       const struct auto_pin_cfg *cfg,
4513                                       hda_nid_t mixer,
4514                                       hda_nid_t cap1, hda_nid_t cap2)
4515 {
4516         struct alc_spec *spec = codec->spec;
4517         struct hda_input_mux *imux = &spec->private_imux[0];
4518         int i, err, idx;
4519
4520         for (i = 0; i < AUTO_PIN_LAST; i++) {
4521                 hda_nid_t pin;
4522
4523                 pin = cfg->input_pins[i];
4524                 if (!alc_is_input_pin(codec, pin))
4525                         continue;
4526
4527                 if (mixer) {
4528                         idx = get_connection_index(codec, mixer, pin);
4529                         if (idx >= 0) {
4530                                 err = new_analog_input(spec, pin,
4531                                                        auto_pin_cfg_labels[i],
4532                                                        idx, mixer);
4533                                 if (err < 0)
4534                                         return err;
4535                         }
4536                 }
4537
4538                 if (!cap1)
4539                         continue;
4540                 idx = get_connection_index(codec, cap1, pin);
4541                 if (idx < 0 && cap2)
4542                         idx = get_connection_index(codec, cap2, pin);
4543                 if (idx >= 0) {
4544                         imux->items[imux->num_items].label =
4545                                 auto_pin_cfg_labels[i];
4546                         imux->items[imux->num_items].index = idx;
4547                         imux->num_items++;
4548                 }
4549         }
4550         return 0;
4551 }
4552
4553 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4554                                                 const struct auto_pin_cfg *cfg)
4555 {
4556         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4557 }
4558
4559 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4560                                unsigned int pin_type)
4561 {
4562         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4563                             pin_type);
4564         /* unmute pin */
4565         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4566                             AMP_OUT_UNMUTE);
4567 }
4568
4569 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4570                                               hda_nid_t nid, int pin_type,
4571                                               int dac_idx)
4572 {
4573         alc_set_pin_output(codec, nid, pin_type);
4574         /* need the manual connection? */
4575         if (alc880_is_multi_pin(nid)) {
4576                 struct alc_spec *spec = codec->spec;
4577                 int idx = alc880_multi_pin_idx(nid);
4578                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4579                                     AC_VERB_SET_CONNECT_SEL,
4580                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4581         }
4582 }
4583
4584 static int get_pin_type(int line_out_type)
4585 {
4586         if (line_out_type == AUTO_PIN_HP_OUT)
4587                 return PIN_HP;
4588         else
4589                 return PIN_OUT;
4590 }
4591
4592 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4593 {
4594         struct alc_spec *spec = codec->spec;
4595         int i;
4596
4597         for (i = 0; i < spec->autocfg.line_outs; i++) {
4598                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4599                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4600                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4601         }
4602 }
4603
4604 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4605 {
4606         struct alc_spec *spec = codec->spec;
4607         hda_nid_t pin;
4608
4609         pin = spec->autocfg.speaker_pins[0];
4610         if (pin) /* connect to front */
4611                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4612         pin = spec->autocfg.hp_pins[0];
4613         if (pin) /* connect to front */
4614                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4615 }
4616
4617 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4618 {
4619         struct alc_spec *spec = codec->spec;
4620         int i;
4621
4622         for (i = 0; i < AUTO_PIN_LAST; i++) {
4623                 hda_nid_t nid = spec->autocfg.input_pins[i];
4624                 if (alc_is_input_pin(codec, nid)) {
4625                         alc_set_input_pin(codec, nid, i);
4626                         if (nid != ALC880_PIN_CD_NID &&
4627                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4628                                 snd_hda_codec_write(codec, nid, 0,
4629                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4630                                                     AMP_OUT_MUTE);
4631                 }
4632         }
4633 }
4634
4635 /* parse the BIOS configuration and set up the alc_spec */
4636 /* return 1 if successful, 0 if the proper config is not found,
4637  * or a negative error code
4638  */
4639 static int alc880_parse_auto_config(struct hda_codec *codec)
4640 {
4641         struct alc_spec *spec = codec->spec;
4642         int i, err;
4643         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4644
4645         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4646                                            alc880_ignore);
4647         if (err < 0)
4648                 return err;
4649         if (!spec->autocfg.line_outs)
4650                 return 0; /* can't find valid BIOS pin config */
4651
4652         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4653         if (err < 0)
4654                 return err;
4655         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4656         if (err < 0)
4657                 return err;
4658         err = alc880_auto_create_extra_out(spec,
4659                                            spec->autocfg.speaker_pins[0],
4660                                            "Speaker");
4661         if (err < 0)
4662                 return err;
4663         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4664                                            "Headphone");
4665         if (err < 0)
4666                 return err;
4667         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4668         if (err < 0)
4669                 return err;
4670
4671         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4672
4673         /* check multiple SPDIF-out (for recent codecs) */
4674         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4675                 hda_nid_t dig_nid;
4676                 err = snd_hda_get_connections(codec,
4677                                               spec->autocfg.dig_out_pins[i],
4678                                               &dig_nid, 1);
4679                 if (err < 0)
4680                         continue;
4681                 if (!i)
4682                         spec->multiout.dig_out_nid = dig_nid;
4683                 else {
4684                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4685                         spec->slave_dig_outs[i - 1] = dig_nid;
4686                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
4687                                 break;
4688                 }
4689         }
4690         if (spec->autocfg.dig_in_pin)
4691                 spec->dig_in_nid = ALC880_DIGIN_NID;
4692
4693         if (spec->kctls.list)
4694                 add_mixer(spec, spec->kctls.list);
4695
4696         add_verb(spec, alc880_volume_init_verbs);
4697
4698         spec->num_mux_defs = 1;
4699         spec->input_mux = &spec->private_imux[0];
4700
4701         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
4702
4703         return 1;
4704 }
4705
4706 /* additional initialization for auto-configuration model */
4707 static void alc880_auto_init(struct hda_codec *codec)
4708 {
4709         struct alc_spec *spec = codec->spec;
4710         alc880_auto_init_multi_out(codec);
4711         alc880_auto_init_extra_out(codec);
4712         alc880_auto_init_analog_input(codec);
4713         if (spec->unsol_event)
4714                 alc_inithook(codec);
4715 }
4716
4717 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4718  * one of two digital mic pins, e.g. on ALC272
4719  */
4720 static void fixup_automic_adc(struct hda_codec *codec)
4721 {
4722         struct alc_spec *spec = codec->spec;
4723         int i;
4724
4725         for (i = 0; i < spec->num_adc_nids; i++) {
4726                 hda_nid_t cap = spec->capsrc_nids ?
4727                         spec->capsrc_nids[i] : spec->adc_nids[i];
4728                 int iidx, eidx;
4729
4730                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4731                 if (iidx < 0)
4732                         continue;
4733                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4734                 if (eidx < 0)
4735                         continue;
4736                 spec->int_mic.mux_idx = iidx;
4737                 spec->ext_mic.mux_idx = eidx;
4738                 if (spec->capsrc_nids)
4739                         spec->capsrc_nids += i;
4740                 spec->adc_nids += i;
4741                 spec->num_adc_nids = 1;
4742                 return;
4743         }
4744         snd_printd(KERN_INFO "hda_codec: %s: "
4745                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4746                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4747         spec->auto_mic = 0; /* disable auto-mic to be sure */
4748 }
4749
4750 static void set_capture_mixer(struct hda_codec *codec)
4751 {
4752         struct alc_spec *spec = codec->spec;
4753         static struct snd_kcontrol_new *caps[2][3] = {
4754                 { alc_capture_mixer_nosrc1,
4755                   alc_capture_mixer_nosrc2,
4756                   alc_capture_mixer_nosrc3 },
4757                 { alc_capture_mixer1,
4758                   alc_capture_mixer2,
4759                   alc_capture_mixer3 },
4760         };
4761         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4762                 int mux;
4763                 if (spec->auto_mic) {
4764                         mux = 0;
4765                         fixup_automic_adc(codec);
4766                 } else if (spec->input_mux && spec->input_mux->num_items > 1)
4767                         mux = 1;
4768                 else
4769                         mux = 0;
4770                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4771         }
4772 }
4773
4774 #define set_beep_amp(spec, nid, idx, dir) \
4775         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
4776
4777 /*
4778  * OK, here we have finally the patch for ALC880
4779  */
4780
4781 static int patch_alc880(struct hda_codec *codec)
4782 {
4783         struct alc_spec *spec;
4784         int board_config;
4785         int err;
4786
4787         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
4788         if (spec == NULL)
4789                 return -ENOMEM;
4790
4791         codec->spec = spec;
4792
4793         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
4794                                                   alc880_models,
4795                                                   alc880_cfg_tbl);
4796         if (board_config < 0) {
4797                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
4798                        codec->chip_name);
4799                 board_config = ALC880_AUTO;
4800         }
4801
4802         if (board_config == ALC880_AUTO) {
4803                 /* automatic parse from the BIOS config */
4804                 err = alc880_parse_auto_config(codec);
4805                 if (err < 0) {
4806                         alc_free(codec);
4807                         return err;
4808                 } else if (!err) {
4809                         printk(KERN_INFO
4810                                "hda_codec: Cannot set up configuration "
4811                                "from BIOS.  Using 3-stack mode...\n");
4812                         board_config = ALC880_3ST;
4813                 }
4814         }
4815
4816         err = snd_hda_attach_beep_device(codec, 0x1);
4817         if (err < 0) {
4818                 alc_free(codec);
4819                 return err;
4820         }
4821
4822         if (board_config != ALC880_AUTO)
4823                 setup_preset(codec, &alc880_presets[board_config]);
4824
4825         spec->stream_analog_playback = &alc880_pcm_analog_playback;
4826         spec->stream_analog_capture = &alc880_pcm_analog_capture;
4827         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
4828
4829         spec->stream_digital_playback = &alc880_pcm_digital_playback;
4830         spec->stream_digital_capture = &alc880_pcm_digital_capture;
4831
4832         if (!spec->adc_nids && spec->input_mux) {
4833                 /* check whether NID 0x07 is valid */
4834                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
4835                 /* get type */
4836                 wcap = get_wcaps_type(wcap);
4837                 if (wcap != AC_WID_AUD_IN) {
4838                         spec->adc_nids = alc880_adc_nids_alt;
4839                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
4840                 } else {
4841                         spec->adc_nids = alc880_adc_nids;
4842                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
4843                 }
4844         }
4845         set_capture_mixer(codec);
4846         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
4847
4848         spec->vmaster_nid = 0x0c;
4849
4850         codec->patch_ops = alc_patch_ops;
4851         if (board_config == ALC880_AUTO)
4852                 spec->init_hook = alc880_auto_init;
4853 #ifdef CONFIG_SND_HDA_POWER_SAVE
4854         if (!spec->loopback.amplist)
4855                 spec->loopback.amplist = alc880_loopbacks;
4856 #endif
4857         codec->proc_widget_hook = print_realtek_coef;
4858
4859         return 0;
4860 }
4861
4862
4863 /*
4864  * ALC260 support
4865  */
4866
4867 static hda_nid_t alc260_dac_nids[1] = {
4868         /* front */
4869         0x02,
4870 };
4871
4872 static hda_nid_t alc260_adc_nids[1] = {
4873         /* ADC0 */
4874         0x04,
4875 };
4876
4877 static hda_nid_t alc260_adc_nids_alt[1] = {
4878         /* ADC1 */
4879         0x05,
4880 };
4881
4882 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
4883  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
4884  */
4885 static hda_nid_t alc260_dual_adc_nids[2] = {
4886         /* ADC0, ADC1 */
4887         0x04, 0x05
4888 };
4889
4890 #define ALC260_DIGOUT_NID       0x03
4891 #define ALC260_DIGIN_NID        0x06
4892
4893 static struct hda_input_mux alc260_capture_source = {
4894         .num_items = 4,
4895         .items = {
4896                 { "Mic", 0x0 },
4897                 { "Front Mic", 0x1 },
4898                 { "Line", 0x2 },
4899                 { "CD", 0x4 },
4900         },
4901 };
4902
4903 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
4904  * headphone jack and the internal CD lines since these are the only pins at
4905  * which audio can appear.  For flexibility, also allow the option of
4906  * recording the mixer output on the second ADC (ADC0 doesn't have a
4907  * connection to the mixer output).
4908  */
4909 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
4910         {
4911                 .num_items = 3,
4912                 .items = {
4913                         { "Mic/Line", 0x0 },
4914                         { "CD", 0x4 },
4915                         { "Headphone", 0x2 },
4916                 },
4917         },
4918         {
4919                 .num_items = 4,
4920                 .items = {
4921                         { "Mic/Line", 0x0 },
4922                         { "CD", 0x4 },
4923                         { "Headphone", 0x2 },
4924                         { "Mixer", 0x5 },
4925                 },
4926         },
4927
4928 };
4929
4930 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
4931  * the Fujitsu S702x, but jacks are marked differently.
4932  */
4933 static struct hda_input_mux alc260_acer_capture_sources[2] = {
4934         {
4935                 .num_items = 4,
4936                 .items = {
4937                         { "Mic", 0x0 },
4938                         { "Line", 0x2 },
4939                         { "CD", 0x4 },
4940                         { "Headphone", 0x5 },
4941                 },
4942         },
4943         {
4944                 .num_items = 5,
4945                 .items = {
4946                         { "Mic", 0x0 },
4947                         { "Line", 0x2 },
4948                         { "CD", 0x4 },
4949                         { "Headphone", 0x6 },
4950                         { "Mixer", 0x5 },
4951                 },
4952         },
4953 };
4954
4955 /* Maxdata Favorit 100XS */
4956 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
4957         {
4958                 .num_items = 2,
4959                 .items = {
4960                         { "Line/Mic", 0x0 },
4961                         { "CD", 0x4 },
4962                 },
4963         },
4964         {
4965                 .num_items = 3,
4966                 .items = {
4967                         { "Line/Mic", 0x0 },
4968                         { "CD", 0x4 },
4969                         { "Mixer", 0x5 },
4970                 },
4971         },
4972 };
4973
4974 /*
4975  * This is just place-holder, so there's something for alc_build_pcms to look
4976  * at when it calculates the maximum number of channels. ALC260 has no mixer
4977  * element which allows changing the channel mode, so the verb list is
4978  * never used.
4979  */
4980 static struct hda_channel_mode alc260_modes[1] = {
4981         { 2, NULL },
4982 };
4983
4984
4985 /* Mixer combinations
4986  *
4987  * basic: base_output + input + pc_beep + capture
4988  * HP: base_output + input + capture_alt
4989  * HP_3013: hp_3013 + input + capture
4990  * fujitsu: fujitsu + capture
4991  * acer: acer + capture
4992  */
4993
4994 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
4995         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
4996         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
4997         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
4998         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
4999         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5000         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5001         { } /* end */
5002 };
5003
5004 static struct snd_kcontrol_new alc260_input_mixer[] = {
5005         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5006         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5007         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5008         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5009         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5010         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5011         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5012         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5013         { } /* end */
5014 };
5015
5016 /* update HP, line and mono out pins according to the master switch */
5017 static void alc260_hp_master_update(struct hda_codec *codec,
5018                                     hda_nid_t hp, hda_nid_t line,
5019                                     hda_nid_t mono)
5020 {
5021         struct alc_spec *spec = codec->spec;
5022         unsigned int val = spec->master_sw ? PIN_HP : 0;
5023         /* change HP and line-out pins */
5024         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5025                             val);
5026         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5027                             val);
5028         /* mono (speaker) depending on the HP jack sense */
5029         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5030         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5031                             val);
5032 }
5033
5034 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5035                                    struct snd_ctl_elem_value *ucontrol)
5036 {
5037         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5038         struct alc_spec *spec = codec->spec;
5039         *ucontrol->value.integer.value = spec->master_sw;
5040         return 0;
5041 }
5042
5043 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5044                                    struct snd_ctl_elem_value *ucontrol)
5045 {
5046         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5047         struct alc_spec *spec = codec->spec;
5048         int val = !!*ucontrol->value.integer.value;
5049         hda_nid_t hp, line, mono;
5050
5051         if (val == spec->master_sw)
5052                 return 0;
5053         spec->master_sw = val;
5054         hp = (kcontrol->private_value >> 16) & 0xff;
5055         line = (kcontrol->private_value >> 8) & 0xff;
5056         mono = kcontrol->private_value & 0xff;
5057         alc260_hp_master_update(codec, hp, line, mono);
5058         return 1;
5059 }
5060
5061 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5062         {
5063                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5064                 .name = "Master Playback Switch",
5065                 .info = snd_ctl_boolean_mono_info,
5066                 .get = alc260_hp_master_sw_get,
5067                 .put = alc260_hp_master_sw_put,
5068                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5069         },
5070         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5071         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5072         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5073         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5074         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5075                               HDA_OUTPUT),
5076         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5077         { } /* end */
5078 };
5079
5080 static struct hda_verb alc260_hp_unsol_verbs[] = {
5081         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5082         {},
5083 };
5084
5085 static void alc260_hp_automute(struct hda_codec *codec)
5086 {
5087         struct alc_spec *spec = codec->spec;
5088         unsigned int present;
5089
5090         present = snd_hda_codec_read(codec, 0x10, 0,
5091                                      AC_VERB_GET_PIN_SENSE, 0);
5092         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5093         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5094 }
5095
5096 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5097 {
5098         if ((res >> 26) == ALC880_HP_EVENT)
5099                 alc260_hp_automute(codec);
5100 }
5101
5102 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5103         {
5104                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5105                 .name = "Master Playback Switch",
5106                 .info = snd_ctl_boolean_mono_info,
5107                 .get = alc260_hp_master_sw_get,
5108                 .put = alc260_hp_master_sw_put,
5109                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5110         },
5111         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5112         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5113         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5114         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5115         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5116         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5117         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5118         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5119         { } /* end */
5120 };
5121
5122 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5123         .ops = &snd_hda_bind_vol,
5124         .values = {
5125                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5126                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5127                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5128                 0
5129         },
5130 };
5131
5132 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5133         .ops = &snd_hda_bind_sw,
5134         .values = {
5135                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5136                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5137                 0
5138         },
5139 };
5140
5141 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5142         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5143         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5144         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5145         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5146         { } /* end */
5147 };
5148
5149 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5150         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5151         {},
5152 };
5153
5154 static void alc260_hp_3013_automute(struct hda_codec *codec)
5155 {
5156         struct alc_spec *spec = codec->spec;
5157         unsigned int present;
5158
5159         present = snd_hda_codec_read(codec, 0x15, 0,
5160                                      AC_VERB_GET_PIN_SENSE, 0);
5161         spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
5162         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5163 }
5164
5165 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5166                                        unsigned int res)
5167 {
5168         if ((res >> 26) == ALC880_HP_EVENT)
5169                 alc260_hp_3013_automute(codec);
5170 }
5171
5172 static void alc260_hp_3012_automute(struct hda_codec *codec)
5173 {
5174         unsigned int present, bits;
5175
5176         present = snd_hda_codec_read(codec, 0x10, 0,
5177                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
5178
5179         bits = present ? 0 : PIN_OUT;
5180         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5181                             bits);
5182         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5183                             bits);
5184         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5185                             bits);
5186 }
5187
5188 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5189                                        unsigned int res)
5190 {
5191         if ((res >> 26) == ALC880_HP_EVENT)
5192                 alc260_hp_3012_automute(codec);
5193 }
5194
5195 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5196  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5197  */
5198 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5199         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5200         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5201         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5202         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5203         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5204         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5205         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5206         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5207         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5208         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5209         { } /* end */
5210 };
5211
5212 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5213  * versions of the ALC260 don't act on requests to enable mic bias from NID
5214  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5215  * datasheet doesn't mention this restriction.  At this stage it's not clear
5216  * whether this behaviour is intentional or is a hardware bug in chip
5217  * revisions available in early 2006.  Therefore for now allow the
5218  * "Headphone Jack Mode" control to span all choices, but if it turns out
5219  * that the lack of mic bias for this NID is intentional we could change the
5220  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5221  *
5222  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5223  * don't appear to make the mic bias available from the "line" jack, even
5224  * though the NID used for this jack (0x14) can supply it.  The theory is
5225  * that perhaps Acer have included blocking capacitors between the ALC260
5226  * and the output jack.  If this turns out to be the case for all such
5227  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5228  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5229  *
5230  * The C20x Tablet series have a mono internal speaker which is controlled
5231  * via the chip's Mono sum widget and pin complex, so include the necessary
5232  * controls for such models.  On models without a "mono speaker" the control
5233  * won't do anything.
5234  */
5235 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5236         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5237         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5238         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5239         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5240                               HDA_OUTPUT),
5241         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5242                            HDA_INPUT),
5243         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5244         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5245         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5246         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5247         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5248         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5249         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5250         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5251         { } /* end */
5252 };
5253
5254 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5255  */
5256 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5257         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5258         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5259         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5260         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5261         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5262         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5263         { } /* end */
5264 };
5265
5266 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5267  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5268  */
5269 static struct snd_kcontrol_new alc260_will_mixer[] = {
5270         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5271         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5273         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5274         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5275         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5276         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5277         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5278         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5279         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5280         { } /* end */
5281 };
5282
5283 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5284  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5285  */
5286 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5287         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5288         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5289         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5290         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5291         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5292         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5293         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5294         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5295         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5296         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5297         { } /* end */
5298 };
5299
5300 /*
5301  * initialization verbs
5302  */
5303 static struct hda_verb alc260_init_verbs[] = {
5304         /* Line In pin widget for input */
5305         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5306         /* CD pin widget for input */
5307         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5308         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5309         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5310         /* Mic2 (front panel) pin widget for input and vref at 80% */
5311         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5312         /* LINE-2 is used for line-out in rear */
5313         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5314         /* select line-out */
5315         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5316         /* LINE-OUT pin */
5317         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5318         /* enable HP */
5319         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5320         /* enable Mono */
5321         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5322         /* mute capture amp left and right */
5323         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5324         /* set connection select to line in (default select for this ADC) */
5325         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5326         /* mute capture amp left and right */
5327         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5328         /* set connection select to line in (default select for this ADC) */
5329         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5330         /* set vol=0 Line-Out mixer amp left and right */
5331         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5332         /* unmute pin widget amp left and right (no gain on this amp) */
5333         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5334         /* set vol=0 HP mixer amp left and right */
5335         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5336         /* unmute pin widget amp left and right (no gain on this amp) */
5337         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5338         /* set vol=0 Mono mixer amp left and right */
5339         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5340         /* unmute pin widget amp left and right (no gain on this amp) */
5341         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5342         /* unmute LINE-2 out pin */
5343         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5344         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5345          * Line In 2 = 0x03
5346          */
5347         /* mute analog inputs */
5348         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5349         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5350         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5351         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5352         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5353         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5354         /* mute Front out path */
5355         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5356         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5357         /* mute Headphone out path */
5358         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5359         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5360         /* mute Mono out path */
5361         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5362         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5363         { }
5364 };
5365
5366 #if 0 /* should be identical with alc260_init_verbs? */
5367 static struct hda_verb alc260_hp_init_verbs[] = {
5368         /* Headphone and output */
5369         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5370         /* mono output */
5371         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5372         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5373         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5374         /* Mic2 (front panel) pin widget for input and vref at 80% */
5375         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5376         /* Line In pin widget for input */
5377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5378         /* Line-2 pin widget for output */
5379         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5380         /* CD pin widget for input */
5381         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5382         /* unmute amp left and right */
5383         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5384         /* set connection select to line in (default select for this ADC) */
5385         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5386         /* unmute Line-Out mixer amp left and right (volume = 0) */
5387         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5388         /* mute pin widget amp left and right (no gain on this amp) */
5389         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5390         /* unmute HP mixer amp left and right (volume = 0) */
5391         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5392         /* mute pin widget amp left and right (no gain on this amp) */
5393         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5394         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5395          * Line In 2 = 0x03
5396          */
5397         /* mute analog inputs */
5398         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5399         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5400         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5401         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5402         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5403         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5404         /* Unmute Front out path */
5405         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5406         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5407         /* Unmute Headphone out path */
5408         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5409         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5410         /* Unmute Mono out path */
5411         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5412         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5413         { }
5414 };
5415 #endif
5416
5417 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5418         /* Line out and output */
5419         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5420         /* mono output */
5421         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5422         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5423         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5424         /* Mic2 (front panel) pin widget for input and vref at 80% */
5425         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5426         /* Line In pin widget for input */
5427         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5428         /* Headphone pin widget for output */
5429         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5430         /* CD pin widget for input */
5431         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5432         /* unmute amp left and right */
5433         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5434         /* set connection select to line in (default select for this ADC) */
5435         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5436         /* unmute Line-Out mixer amp left and right (volume = 0) */
5437         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5438         /* mute pin widget amp left and right (no gain on this amp) */
5439         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5440         /* unmute HP mixer amp left and right (volume = 0) */
5441         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5442         /* mute pin widget amp left and right (no gain on this amp) */
5443         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5444         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5445          * Line In 2 = 0x03
5446          */
5447         /* mute analog inputs */
5448         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5449         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5450         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5451         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5452         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5453         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5454         /* Unmute Front out path */
5455         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5456         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5457         /* Unmute Headphone out path */
5458         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5459         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5460         /* Unmute Mono out path */
5461         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5462         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5463         { }
5464 };
5465
5466 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5467  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5468  * audio = 0x16, internal speaker = 0x10.
5469  */
5470 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5471         /* Disable all GPIOs */
5472         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5473         /* Internal speaker is connected to headphone pin */
5474         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5475         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5476         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5477         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5478         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5479         /* Ensure all other unused pins are disabled and muted. */
5480         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5481         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5482         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5483         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5484         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5485         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5486         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5487         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5488
5489         /* Disable digital (SPDIF) pins */
5490         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5491         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5492
5493         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5494          * when acting as an output.
5495          */
5496         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5497
5498         /* Start with output sum widgets muted and their output gains at min */
5499         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5500         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5501         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5502         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5503         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5504         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5505         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5506         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5507         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5508
5509         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5510         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5511         /* Unmute Line1 pin widget output buffer since it starts as an output.
5512          * If the pin mode is changed by the user the pin mode control will
5513          * take care of enabling the pin's input/output buffers as needed.
5514          * Therefore there's no need to enable the input buffer at this
5515          * stage.
5516          */
5517         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5518         /* Unmute input buffer of pin widget used for Line-in (no equiv
5519          * mixer ctrl)
5520          */
5521         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5522
5523         /* Mute capture amp left and right */
5524         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5525         /* Set ADC connection select to match default mixer setting - line
5526          * in (on mic1 pin)
5527          */
5528         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5529
5530         /* Do the same for the second ADC: mute capture input amp and
5531          * set ADC connection to line in (on mic1 pin)
5532          */
5533         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5534         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5535
5536         /* Mute all inputs to mixer widget (even unconnected ones) */
5537         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5538         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5539         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5540         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5541         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5542         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5543         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5544         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5545
5546         { }
5547 };
5548
5549 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5550  * similar laptops (adapted from Fujitsu init verbs).
5551  */
5552 static struct hda_verb alc260_acer_init_verbs[] = {
5553         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5554          * the headphone jack.  Turn this on and rely on the standard mute
5555          * methods whenever the user wants to turn these outputs off.
5556          */
5557         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5558         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5559         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5560         /* Internal speaker/Headphone jack is connected to Line-out pin */
5561         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5562         /* Internal microphone/Mic jack is connected to Mic1 pin */
5563         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5564         /* Line In jack is connected to Line1 pin */
5565         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5566         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5567         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5568         /* Ensure all other unused pins are disabled and muted. */
5569         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5570         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5571         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5572         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5573         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5574         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5575         /* Disable digital (SPDIF) pins */
5576         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5577         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5578
5579         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5580          * bus when acting as outputs.
5581          */
5582         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5583         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5584
5585         /* Start with output sum widgets muted and their output gains at min */
5586         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5587         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5588         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5589         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5590         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5591         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5592         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5593         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5594         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5595
5596         /* Unmute Line-out pin widget amp left and right
5597          * (no equiv mixer ctrl)
5598          */
5599         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5600         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5601         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5602         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5603          * inputs. If the pin mode is changed by the user the pin mode control
5604          * will take care of enabling the pin's input/output buffers as needed.
5605          * Therefore there's no need to enable the input buffer at this
5606          * stage.
5607          */
5608         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5609         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5610
5611         /* Mute capture amp left and right */
5612         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5613         /* Set ADC connection select to match default mixer setting - mic
5614          * (on mic1 pin)
5615          */
5616         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5617
5618         /* Do similar with the second ADC: mute capture input amp and
5619          * set ADC connection to mic to match ALSA's default state.
5620          */
5621         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5622         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5623
5624         /* Mute all inputs to mixer widget (even unconnected ones) */
5625         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5626         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5627         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5628         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5629         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5630         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5631         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5632         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5633
5634         { }
5635 };
5636
5637 /* Initialisation sequence for Maxdata Favorit 100XS
5638  * (adapted from Acer init verbs).
5639  */
5640 static struct hda_verb alc260_favorit100_init_verbs[] = {
5641         /* GPIO 0 enables the output jack.
5642          * Turn this on and rely on the standard mute
5643          * methods whenever the user wants to turn these outputs off.
5644          */
5645         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5646         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5647         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5648         /* Line/Mic input jack is connected to Mic1 pin */
5649         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5650         /* Ensure all other unused pins are disabled and muted. */
5651         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5652         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5653         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5654         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5655         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5656         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5657         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5658         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5659         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5660         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5661         /* Disable digital (SPDIF) pins */
5662         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5663         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5664
5665         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5666          * bus when acting as outputs.
5667          */
5668         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5669         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5670
5671         /* Start with output sum widgets muted and their output gains at min */
5672         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5673         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5674         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5675         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5676         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5677         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5678         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5679         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5680         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5681
5682         /* Unmute Line-out pin widget amp left and right
5683          * (no equiv mixer ctrl)
5684          */
5685         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5686         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5687          * inputs. If the pin mode is changed by the user the pin mode control
5688          * will take care of enabling the pin's input/output buffers as needed.
5689          * Therefore there's no need to enable the input buffer at this
5690          * stage.
5691          */
5692         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5693
5694         /* Mute capture amp left and right */
5695         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5696         /* Set ADC connection select to match default mixer setting - mic
5697          * (on mic1 pin)
5698          */
5699         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5700
5701         /* Do similar with the second ADC: mute capture input amp and
5702          * set ADC connection to mic to match ALSA's default state.
5703          */
5704         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5705         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5706
5707         /* Mute all inputs to mixer widget (even unconnected ones) */
5708         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5709         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5710         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5711         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5712         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5713         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5714         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5715         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5716
5717         { }
5718 };
5719
5720 static struct hda_verb alc260_will_verbs[] = {
5721         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5722         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
5723         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
5724         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5725         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5726         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
5727         {}
5728 };
5729
5730 static struct hda_verb alc260_replacer_672v_verbs[] = {
5731         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
5732         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
5733         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
5734
5735         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5736         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5737         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5738
5739         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5740         {}
5741 };
5742
5743 /* toggle speaker-output according to the hp-jack state */
5744 static void alc260_replacer_672v_automute(struct hda_codec *codec)
5745 {
5746         unsigned int present;
5747
5748         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
5749         present = snd_hda_codec_read(codec, 0x0f, 0,
5750                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
5751         if (present) {
5752                 snd_hda_codec_write_cache(codec, 0x01, 0,
5753                                           AC_VERB_SET_GPIO_DATA, 1);
5754                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5755                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5756                                           PIN_HP);
5757         } else {
5758                 snd_hda_codec_write_cache(codec, 0x01, 0,
5759                                           AC_VERB_SET_GPIO_DATA, 0);
5760                 snd_hda_codec_write_cache(codec, 0x0f, 0,
5761                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
5762                                           PIN_OUT);
5763         }
5764 }
5765
5766 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
5767                                        unsigned int res)
5768 {
5769         if ((res >> 26) == ALC880_HP_EVENT)
5770                 alc260_replacer_672v_automute(codec);
5771 }
5772
5773 static struct hda_verb alc260_hp_dc7600_verbs[] = {
5774         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
5775         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
5776         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5777         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5778         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5779         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5780         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5781         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5782         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5783         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5784         {}
5785 };
5786
5787 /* Test configuration for debugging, modelled after the ALC880 test
5788  * configuration.
5789  */
5790 #ifdef CONFIG_SND_DEBUG
5791 static hda_nid_t alc260_test_dac_nids[1] = {
5792         0x02,
5793 };
5794 static hda_nid_t alc260_test_adc_nids[2] = {
5795         0x04, 0x05,
5796 };
5797 /* For testing the ALC260, each input MUX needs its own definition since
5798  * the signal assignments are different.  This assumes that the first ADC
5799  * is NID 0x04.
5800  */
5801 static struct hda_input_mux alc260_test_capture_sources[2] = {
5802         {
5803                 .num_items = 7,
5804                 .items = {
5805                         { "MIC1 pin", 0x0 },
5806                         { "MIC2 pin", 0x1 },
5807                         { "LINE1 pin", 0x2 },
5808                         { "LINE2 pin", 0x3 },
5809                         { "CD pin", 0x4 },
5810                         { "LINE-OUT pin", 0x5 },
5811                         { "HP-OUT pin", 0x6 },
5812                 },
5813         },
5814         {
5815                 .num_items = 8,
5816                 .items = {
5817                         { "MIC1 pin", 0x0 },
5818                         { "MIC2 pin", 0x1 },
5819                         { "LINE1 pin", 0x2 },
5820                         { "LINE2 pin", 0x3 },
5821                         { "CD pin", 0x4 },
5822                         { "Mixer", 0x5 },
5823                         { "LINE-OUT pin", 0x6 },
5824                         { "HP-OUT pin", 0x7 },
5825                 },
5826         },
5827 };
5828 static struct snd_kcontrol_new alc260_test_mixer[] = {
5829         /* Output driver widgets */
5830         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5831         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5832         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5833         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
5834         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5835         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
5836
5837         /* Modes for retasking pin widgets
5838          * Note: the ALC260 doesn't seem to act on requests to enable mic
5839          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
5840          * mention this restriction.  At this stage it's not clear whether
5841          * this behaviour is intentional or is a hardware bug in chip
5842          * revisions available at least up until early 2006.  Therefore for
5843          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
5844          * choices, but if it turns out that the lack of mic bias for these
5845          * NIDs is intentional we could change their modes from
5846          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5847          */
5848         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
5849         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
5850         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
5851         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
5852         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
5853         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
5854
5855         /* Loopback mixer controls */
5856         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
5857         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
5858         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
5859         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
5860         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
5861         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
5862         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
5863         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
5864         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5865         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5866         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
5867         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
5868         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
5869         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
5870
5871         /* Controls for GPIO pins, assuming they are configured as outputs */
5872         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
5873         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
5874         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
5875         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
5876
5877         /* Switches to allow the digital IO pins to be enabled.  The datasheet
5878          * is ambigious as to which NID is which; testing on laptops which
5879          * make this output available should provide clarification.
5880          */
5881         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
5882         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
5883
5884         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
5885          * this output to turn on an external amplifier.
5886          */
5887         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
5888         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
5889
5890         { } /* end */
5891 };
5892 static struct hda_verb alc260_test_init_verbs[] = {
5893         /* Enable all GPIOs as outputs with an initial value of 0 */
5894         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
5895         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
5896         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
5897
5898         /* Enable retasking pins as output, initially without power amp */
5899         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5900         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5901         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5902         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5903         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5904         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5905
5906         /* Disable digital (SPDIF) pins initially, but users can enable
5907          * them via a mixer switch.  In the case of SPDIF-out, this initverb
5908          * payload also sets the generation to 0, output to be in "consumer"
5909          * PCM format, copyright asserted, no pre-emphasis and no validity
5910          * control.
5911          */
5912         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5913         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5914
5915         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
5916          * OUT1 sum bus when acting as an output.
5917          */
5918         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5919         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
5920         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5921         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
5922
5923         /* Start with output sum widgets muted and their output gains at min */
5924         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5925         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5926         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5927         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5928         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5929         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5930         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5931         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5932         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5933
5934         /* Unmute retasking pin widget output buffers since the default
5935          * state appears to be output.  As the pin mode is changed by the
5936          * user the pin mode control will take care of enabling the pin's
5937          * input/output buffers as needed.
5938          */
5939         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5940         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5941         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5942         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5943         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5944         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5945         /* Also unmute the mono-out pin widget */
5946         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5947
5948         /* Mute capture amp left and right */
5949         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5950         /* Set ADC connection select to match default mixer setting (mic1
5951          * pin)
5952          */
5953         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5954
5955         /* Do the same for the second ADC: mute capture input amp and
5956          * set ADC connection to mic1 pin
5957          */
5958         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5959         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5960
5961         /* Mute all inputs to mixer widget (even unconnected ones) */
5962         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5963         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5964         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5965         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5966         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5967         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5968         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5969         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5970
5971         { }
5972 };
5973 #endif
5974
5975 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
5976 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
5977
5978 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
5979 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
5980
5981 /*
5982  * for BIOS auto-configuration
5983  */
5984
5985 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
5986                                         const char *pfx, int *vol_bits)
5987 {
5988         hda_nid_t nid_vol;
5989         unsigned long vol_val, sw_val;
5990         char name[32];
5991         int err;
5992
5993         if (nid >= 0x0f && nid < 0x11) {
5994                 nid_vol = nid - 0x7;
5995                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
5996                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
5997         } else if (nid == 0x11) {
5998                 nid_vol = nid - 0x7;
5999                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6000                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6001         } else if (nid >= 0x12 && nid <= 0x15) {
6002                 nid_vol = 0x08;
6003                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6004                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6005         } else
6006                 return 0; /* N/A */
6007
6008         if (!(*vol_bits & (1 << nid_vol))) {
6009                 /* first control for the volume widget */
6010                 snprintf(name, sizeof(name), "%s Playback Volume", pfx);
6011                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name, vol_val);
6012                 if (err < 0)
6013                         return err;
6014                 *vol_bits |= (1 << nid_vol);
6015         }
6016         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
6017         err = add_control(spec, ALC_CTL_WIDGET_MUTE, name, sw_val);
6018         if (err < 0)
6019                 return err;
6020         return 1;
6021 }
6022
6023 /* add playback controls from the parsed DAC table */
6024 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6025                                              const struct auto_pin_cfg *cfg)
6026 {
6027         hda_nid_t nid;
6028         int err;
6029         int vols = 0;
6030
6031         spec->multiout.num_dacs = 1;
6032         spec->multiout.dac_nids = spec->private_dac_nids;
6033         spec->multiout.dac_nids[0] = 0x02;
6034
6035         nid = cfg->line_out_pins[0];
6036         if (nid) {
6037                 const char *pfx;
6038                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6039                         pfx = "Master";
6040                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6041                         pfx = "Speaker";
6042                 else
6043                         pfx = "Front";
6044                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6045                 if (err < 0)
6046                         return err;
6047         }
6048
6049         nid = cfg->speaker_pins[0];
6050         if (nid) {
6051                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6052                 if (err < 0)
6053                         return err;
6054         }
6055
6056         nid = cfg->hp_pins[0];
6057         if (nid) {
6058                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6059                                                    &vols);
6060                 if (err < 0)
6061                         return err;
6062         }
6063         return 0;
6064 }
6065
6066 /* create playback/capture controls for input pins */
6067 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6068                                                 const struct auto_pin_cfg *cfg)
6069 {
6070         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6071 }
6072
6073 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6074                                               hda_nid_t nid, int pin_type,
6075                                               int sel_idx)
6076 {
6077         alc_set_pin_output(codec, nid, pin_type);
6078         /* need the manual connection? */
6079         if (nid >= 0x12) {
6080                 int idx = nid - 0x12;
6081                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6082                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6083         }
6084 }
6085
6086 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6087 {
6088         struct alc_spec *spec = codec->spec;
6089         hda_nid_t nid;
6090
6091         nid = spec->autocfg.line_out_pins[0];
6092         if (nid) {
6093                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6094                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6095         }
6096
6097         nid = spec->autocfg.speaker_pins[0];
6098         if (nid)
6099                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6100
6101         nid = spec->autocfg.hp_pins[0];
6102         if (nid)
6103                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6104 }
6105
6106 #define ALC260_PIN_CD_NID               0x16
6107 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6108 {
6109         struct alc_spec *spec = codec->spec;
6110         int i;
6111
6112         for (i = 0; i < AUTO_PIN_LAST; i++) {
6113                 hda_nid_t nid = spec->autocfg.input_pins[i];
6114                 if (nid >= 0x12) {
6115                         alc_set_input_pin(codec, nid, i);
6116                         if (nid != ALC260_PIN_CD_NID &&
6117                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6118                                 snd_hda_codec_write(codec, nid, 0,
6119                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6120                                                     AMP_OUT_MUTE);
6121                 }
6122         }
6123 }
6124
6125 /*
6126  * generic initialization of ADC, input mixers and output mixers
6127  */
6128 static struct hda_verb alc260_volume_init_verbs[] = {
6129         /*
6130          * Unmute ADC0-1 and set the default input to mic-in
6131          */
6132         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6133         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6134         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6135         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6136
6137         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6138          * mixer widget
6139          * Note: PASD motherboards uses the Line In 2 as the input for
6140          * front panel mic (mic 2)
6141          */
6142         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6143         /* mute analog inputs */
6144         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6145         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6146         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6147         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6148         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6149
6150         /*
6151          * Set up output mixers (0x08 - 0x0a)
6152          */
6153         /* set vol=0 to output mixers */
6154         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6155         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6156         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6157         /* set up input amps for analog loopback */
6158         /* Amp Indices: DAC = 0, mixer = 1 */
6159         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6160         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6161         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6162         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6163         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6164         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6165
6166         { }
6167 };
6168
6169 static int alc260_parse_auto_config(struct hda_codec *codec)
6170 {
6171         struct alc_spec *spec = codec->spec;
6172         int err;
6173         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6174
6175         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6176                                            alc260_ignore);
6177         if (err < 0)
6178                 return err;
6179         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6180         if (err < 0)
6181                 return err;
6182         if (!spec->kctls.list)
6183                 return 0; /* can't find valid BIOS pin config */
6184         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6185         if (err < 0)
6186                 return err;
6187
6188         spec->multiout.max_channels = 2;
6189
6190         if (spec->autocfg.dig_outs)
6191                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6192         if (spec->kctls.list)
6193                 add_mixer(spec, spec->kctls.list);
6194
6195         add_verb(spec, alc260_volume_init_verbs);
6196
6197         spec->num_mux_defs = 1;
6198         spec->input_mux = &spec->private_imux[0];
6199
6200         alc_ssid_check(codec, 0x10, 0x15, 0x0f);
6201
6202         return 1;
6203 }
6204
6205 /* additional initialization for auto-configuration model */
6206 static void alc260_auto_init(struct hda_codec *codec)
6207 {
6208         struct alc_spec *spec = codec->spec;
6209         alc260_auto_init_multi_out(codec);
6210         alc260_auto_init_analog_input(codec);
6211         if (spec->unsol_event)
6212                 alc_inithook(codec);
6213 }
6214
6215 #ifdef CONFIG_SND_HDA_POWER_SAVE
6216 static struct hda_amp_list alc260_loopbacks[] = {
6217         { 0x07, HDA_INPUT, 0 },
6218         { 0x07, HDA_INPUT, 1 },
6219         { 0x07, HDA_INPUT, 2 },
6220         { 0x07, HDA_INPUT, 3 },
6221         { 0x07, HDA_INPUT, 4 },
6222         { } /* end */
6223 };
6224 #endif
6225
6226 /*
6227  * ALC260 configurations
6228  */
6229 static const char *alc260_models[ALC260_MODEL_LAST] = {
6230         [ALC260_BASIC]          = "basic",
6231         [ALC260_HP]             = "hp",
6232         [ALC260_HP_3013]        = "hp-3013",
6233         [ALC260_HP_DC7600]      = "hp-dc7600",
6234         [ALC260_FUJITSU_S702X]  = "fujitsu",
6235         [ALC260_ACER]           = "acer",
6236         [ALC260_WILL]           = "will",
6237         [ALC260_REPLACER_672V]  = "replacer",
6238         [ALC260_FAVORIT100]     = "favorit100",
6239 #ifdef CONFIG_SND_DEBUG
6240         [ALC260_TEST]           = "test",
6241 #endif
6242         [ALC260_AUTO]           = "auto",
6243 };
6244
6245 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6246         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6247         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6248         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6249         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6250         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_HP_3013),
6251         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6252         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6253         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6254         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6255         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6256         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6257         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6258         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6259         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6260         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6261         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6262         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6263         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6264         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6265         {}
6266 };
6267
6268 static struct alc_config_preset alc260_presets[] = {
6269         [ALC260_BASIC] = {
6270                 .mixers = { alc260_base_output_mixer,
6271                             alc260_input_mixer },
6272                 .init_verbs = { alc260_init_verbs },
6273                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6274                 .dac_nids = alc260_dac_nids,
6275                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6276                 .adc_nids = alc260_adc_nids,
6277                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6278                 .channel_mode = alc260_modes,
6279                 .input_mux = &alc260_capture_source,
6280         },
6281         [ALC260_HP] = {
6282                 .mixers = { alc260_hp_output_mixer,
6283                             alc260_input_mixer },
6284                 .init_verbs = { alc260_init_verbs,
6285                                 alc260_hp_unsol_verbs },
6286                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6287                 .dac_nids = alc260_dac_nids,
6288                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6289                 .adc_nids = alc260_adc_nids_alt,
6290                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6291                 .channel_mode = alc260_modes,
6292                 .input_mux = &alc260_capture_source,
6293                 .unsol_event = alc260_hp_unsol_event,
6294                 .init_hook = alc260_hp_automute,
6295         },
6296         [ALC260_HP_DC7600] = {
6297                 .mixers = { alc260_hp_dc7600_mixer,
6298                             alc260_input_mixer },
6299                 .init_verbs = { alc260_init_verbs,
6300                                 alc260_hp_dc7600_verbs },
6301                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6302                 .dac_nids = alc260_dac_nids,
6303                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6304                 .adc_nids = alc260_adc_nids_alt,
6305                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6306                 .channel_mode = alc260_modes,
6307                 .input_mux = &alc260_capture_source,
6308                 .unsol_event = alc260_hp_3012_unsol_event,
6309                 .init_hook = alc260_hp_3012_automute,
6310         },
6311         [ALC260_HP_3013] = {
6312                 .mixers = { alc260_hp_3013_mixer,
6313                             alc260_input_mixer },
6314                 .init_verbs = { alc260_hp_3013_init_verbs,
6315                                 alc260_hp_3013_unsol_verbs },
6316                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6317                 .dac_nids = alc260_dac_nids,
6318                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6319                 .adc_nids = alc260_adc_nids_alt,
6320                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6321                 .channel_mode = alc260_modes,
6322                 .input_mux = &alc260_capture_source,
6323                 .unsol_event = alc260_hp_3013_unsol_event,
6324                 .init_hook = alc260_hp_3013_automute,
6325         },
6326         [ALC260_FUJITSU_S702X] = {
6327                 .mixers = { alc260_fujitsu_mixer },
6328                 .init_verbs = { alc260_fujitsu_init_verbs },
6329                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6330                 .dac_nids = alc260_dac_nids,
6331                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6332                 .adc_nids = alc260_dual_adc_nids,
6333                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6334                 .channel_mode = alc260_modes,
6335                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6336                 .input_mux = alc260_fujitsu_capture_sources,
6337         },
6338         [ALC260_ACER] = {
6339                 .mixers = { alc260_acer_mixer },
6340                 .init_verbs = { alc260_acer_init_verbs },
6341                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6342                 .dac_nids = alc260_dac_nids,
6343                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6344                 .adc_nids = alc260_dual_adc_nids,
6345                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6346                 .channel_mode = alc260_modes,
6347                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6348                 .input_mux = alc260_acer_capture_sources,
6349         },
6350         [ALC260_FAVORIT100] = {
6351                 .mixers = { alc260_favorit100_mixer },
6352                 .init_verbs = { alc260_favorit100_init_verbs },
6353                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6354                 .dac_nids = alc260_dac_nids,
6355                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6356                 .adc_nids = alc260_dual_adc_nids,
6357                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6358                 .channel_mode = alc260_modes,
6359                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6360                 .input_mux = alc260_favorit100_capture_sources,
6361         },
6362         [ALC260_WILL] = {
6363                 .mixers = { alc260_will_mixer },
6364                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6365                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6366                 .dac_nids = alc260_dac_nids,
6367                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6368                 .adc_nids = alc260_adc_nids,
6369                 .dig_out_nid = ALC260_DIGOUT_NID,
6370                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6371                 .channel_mode = alc260_modes,
6372                 .input_mux = &alc260_capture_source,
6373         },
6374         [ALC260_REPLACER_672V] = {
6375                 .mixers = { alc260_replacer_672v_mixer },
6376                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6377                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6378                 .dac_nids = alc260_dac_nids,
6379                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6380                 .adc_nids = alc260_adc_nids,
6381                 .dig_out_nid = ALC260_DIGOUT_NID,
6382                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6383                 .channel_mode = alc260_modes,
6384                 .input_mux = &alc260_capture_source,
6385                 .unsol_event = alc260_replacer_672v_unsol_event,
6386                 .init_hook = alc260_replacer_672v_automute,
6387         },
6388 #ifdef CONFIG_SND_DEBUG
6389         [ALC260_TEST] = {
6390                 .mixers = { alc260_test_mixer },
6391                 .init_verbs = { alc260_test_init_verbs },
6392                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6393                 .dac_nids = alc260_test_dac_nids,
6394                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6395                 .adc_nids = alc260_test_adc_nids,
6396                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6397                 .channel_mode = alc260_modes,
6398                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6399                 .input_mux = alc260_test_capture_sources,
6400         },
6401 #endif
6402 };
6403
6404 static int patch_alc260(struct hda_codec *codec)
6405 {
6406         struct alc_spec *spec;
6407         int err, board_config;
6408
6409         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6410         if (spec == NULL)
6411                 return -ENOMEM;
6412
6413         codec->spec = spec;
6414
6415         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6416                                                   alc260_models,
6417                                                   alc260_cfg_tbl);
6418         if (board_config < 0) {
6419                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6420                            codec->chip_name);
6421                 board_config = ALC260_AUTO;
6422         }
6423
6424         if (board_config == ALC260_AUTO) {
6425                 /* automatic parse from the BIOS config */
6426                 err = alc260_parse_auto_config(codec);
6427                 if (err < 0) {
6428                         alc_free(codec);
6429                         return err;
6430                 } else if (!err) {
6431                         printk(KERN_INFO
6432                                "hda_codec: Cannot set up configuration "
6433                                "from BIOS.  Using base mode...\n");
6434                         board_config = ALC260_BASIC;
6435                 }
6436         }
6437
6438         err = snd_hda_attach_beep_device(codec, 0x1);
6439         if (err < 0) {
6440                 alc_free(codec);
6441                 return err;
6442         }
6443
6444         if (board_config != ALC260_AUTO)
6445                 setup_preset(codec, &alc260_presets[board_config]);
6446
6447         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6448         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6449
6450         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6451         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6452
6453         if (!spec->adc_nids && spec->input_mux) {
6454                 /* check whether NID 0x04 is valid */
6455                 unsigned int wcap = get_wcaps(codec, 0x04);
6456                 wcap = get_wcaps_type(wcap);
6457                 /* get type */
6458                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6459                         spec->adc_nids = alc260_adc_nids_alt;
6460                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6461                 } else {
6462                         spec->adc_nids = alc260_adc_nids;
6463                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6464                 }
6465         }
6466         set_capture_mixer(codec);
6467         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6468
6469         spec->vmaster_nid = 0x08;
6470
6471         codec->patch_ops = alc_patch_ops;
6472         if (board_config == ALC260_AUTO)
6473                 spec->init_hook = alc260_auto_init;
6474 #ifdef CONFIG_SND_HDA_POWER_SAVE
6475         if (!spec->loopback.amplist)
6476                 spec->loopback.amplist = alc260_loopbacks;
6477 #endif
6478         codec->proc_widget_hook = print_realtek_coef;
6479
6480         return 0;
6481 }
6482
6483
6484 /*
6485  * ALC882/883/885/888/889 support
6486  *
6487  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6488  * configuration.  Each pin widget can choose any input DACs and a mixer.
6489  * Each ADC is connected from a mixer of all inputs.  This makes possible
6490  * 6-channel independent captures.
6491  *
6492  * In addition, an independent DAC for the multi-playback (not used in this
6493  * driver yet).
6494  */
6495 #define ALC882_DIGOUT_NID       0x06
6496 #define ALC882_DIGIN_NID        0x0a
6497 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6498 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6499 #define ALC1200_DIGOUT_NID      0x10
6500
6501
6502 static struct hda_channel_mode alc882_ch_modes[1] = {
6503         { 8, NULL }
6504 };
6505
6506 /* DACs */
6507 static hda_nid_t alc882_dac_nids[4] = {
6508         /* front, rear, clfe, rear_surr */
6509         0x02, 0x03, 0x04, 0x05
6510 };
6511 #define alc883_dac_nids         alc882_dac_nids
6512
6513 /* ADCs */
6514 #define alc882_adc_nids         alc880_adc_nids
6515 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6516 #define alc883_adc_nids         alc882_adc_nids_alt
6517 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6518 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6519 #define alc889_adc_nids         alc880_adc_nids
6520
6521 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6522 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6523 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6524 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6525 #define alc889_capsrc_nids      alc882_capsrc_nids
6526
6527 /* input MUX */
6528 /* FIXME: should be a matrix-type input source selection */
6529
6530 static struct hda_input_mux alc882_capture_source = {
6531         .num_items = 4,
6532         .items = {
6533                 { "Mic", 0x0 },
6534                 { "Front Mic", 0x1 },
6535                 { "Line", 0x2 },
6536                 { "CD", 0x4 },
6537         },
6538 };
6539
6540 #define alc883_capture_source   alc882_capture_source
6541
6542 static struct hda_input_mux alc889_capture_source = {
6543         .num_items = 3,
6544         .items = {
6545                 { "Front Mic", 0x0 },
6546                 { "Mic", 0x3 },
6547                 { "Line", 0x2 },
6548         },
6549 };
6550
6551 static struct hda_input_mux mb5_capture_source = {
6552         .num_items = 3,
6553         .items = {
6554                 { "Mic", 0x1 },
6555                 { "Line", 0x2 },
6556                 { "CD", 0x4 },
6557         },
6558 };
6559
6560 static struct hda_input_mux alc883_3stack_6ch_intel = {
6561         .num_items = 4,
6562         .items = {
6563                 { "Mic", 0x1 },
6564                 { "Front Mic", 0x0 },
6565                 { "Line", 0x2 },
6566                 { "CD", 0x4 },
6567         },
6568 };
6569
6570 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6571         .num_items = 2,
6572         .items = {
6573                 { "Mic", 0x1 },
6574                 { "Line", 0x2 },
6575         },
6576 };
6577
6578 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6579         .num_items = 4,
6580         .items = {
6581                 { "Mic", 0x0 },
6582                 { "iMic", 0x1 },
6583                 { "Line", 0x2 },
6584                 { "CD", 0x4 },
6585         },
6586 };
6587
6588 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6589         .num_items = 2,
6590         .items = {
6591                 { "Mic", 0x0 },
6592                 { "Int Mic", 0x1 },
6593         },
6594 };
6595
6596 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6597         .num_items = 3,
6598         .items = {
6599                 { "Mic", 0x0 },
6600                 { "Front Mic", 0x1 },
6601                 { "Line", 0x4 },
6602         },
6603 };
6604
6605 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6606         .num_items = 2,
6607         .items = {
6608                 { "Mic", 0x0 },
6609                 { "Line", 0x2 },
6610         },
6611 };
6612
6613 static struct hda_input_mux alc889A_mb31_capture_source = {
6614         .num_items = 2,
6615         .items = {
6616                 { "Mic", 0x0 },
6617                 /* Front Mic (0x01) unused */
6618                 { "Line", 0x2 },
6619                 /* Line 2 (0x03) unused */
6620                 /* CD (0x04) unsused? */
6621         },
6622 };
6623
6624 /*
6625  * 2ch mode
6626  */
6627 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6628         { 2, NULL }
6629 };
6630
6631 /*
6632  * 2ch mode
6633  */
6634 static struct hda_verb alc882_3ST_ch2_init[] = {
6635         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6636         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6637         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6638         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6639         { } /* end */
6640 };
6641
6642 /*
6643  * 4ch mode
6644  */
6645 static struct hda_verb alc882_3ST_ch4_init[] = {
6646         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6647         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6648         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6649         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6650         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6651         { } /* end */
6652 };
6653
6654 /*
6655  * 6ch mode
6656  */
6657 static struct hda_verb alc882_3ST_ch6_init[] = {
6658         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6659         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6660         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6661         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6662         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6663         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6664         { } /* end */
6665 };
6666
6667 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6668         { 2, alc882_3ST_ch2_init },
6669         { 4, alc882_3ST_ch4_init },
6670         { 6, alc882_3ST_ch6_init },
6671 };
6672
6673 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6674
6675 /*
6676  * 2ch mode
6677  */
6678 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6679         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6680         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6681         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6682         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6683         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6684         { } /* end */
6685 };
6686
6687 /*
6688  * 4ch mode
6689  */
6690 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6691         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6692         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6693         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6694         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6695         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6696         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6697         { } /* end */
6698 };
6699
6700 /*
6701  * 6ch mode
6702  */
6703 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6704         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6705         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6706         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6707         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6708         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6709         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6710         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6711         { } /* end */
6712 };
6713
6714 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6715         { 2, alc883_3ST_ch2_clevo_init },
6716         { 4, alc883_3ST_ch4_clevo_init },
6717         { 6, alc883_3ST_ch6_clevo_init },
6718 };
6719
6720
6721 /*
6722  * 6ch mode
6723  */
6724 static struct hda_verb alc882_sixstack_ch6_init[] = {
6725         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6726         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6727         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6728         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6729         { } /* end */
6730 };
6731
6732 /*
6733  * 8ch mode
6734  */
6735 static struct hda_verb alc882_sixstack_ch8_init[] = {
6736         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6737         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6738         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6739         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6740         { } /* end */
6741 };
6742
6743 static struct hda_channel_mode alc882_sixstack_modes[2] = {
6744         { 6, alc882_sixstack_ch6_init },
6745         { 8, alc882_sixstack_ch8_init },
6746 };
6747
6748 /*
6749  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
6750  */
6751
6752 /*
6753  * 2ch mode
6754  */
6755 static struct hda_verb alc885_mbp_ch2_init[] = {
6756         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6757         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6758         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6759         { } /* end */
6760 };
6761
6762 /*
6763  * 4ch mode
6764  */
6765 static struct hda_verb alc885_mbp_ch4_init[] = {
6766         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6767         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6768         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6769         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6770         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6771         { } /* end */
6772 };
6773
6774 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
6775         { 2, alc885_mbp_ch2_init },
6776         { 4, alc885_mbp_ch4_init },
6777 };
6778
6779 /*
6780  * 2ch
6781  * Speakers/Woofer/HP = Front
6782  * LineIn = Input
6783  */
6784 static struct hda_verb alc885_mb5_ch2_init[] = {
6785         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
6786         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
6787         { } /* end */
6788 };
6789
6790 /*
6791  * 6ch mode
6792  * Speakers/HP = Front
6793  * Woofer = LFE
6794  * LineIn = Surround
6795  */
6796 static struct hda_verb alc885_mb5_ch6_init[] = {
6797         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6798         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6799         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6800         { } /* end */
6801 };
6802
6803 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
6804         { 2, alc885_mb5_ch2_init },
6805         { 6, alc885_mb5_ch6_init },
6806 };
6807
6808
6809 /*
6810  * 2ch mode
6811  */
6812 static struct hda_verb alc883_4ST_ch2_init[] = {
6813         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6814         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6815         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6816         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6817         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6818         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6819         { } /* end */
6820 };
6821
6822 /*
6823  * 4ch mode
6824  */
6825 static struct hda_verb alc883_4ST_ch4_init[] = {
6826         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6827         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6828         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6829         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6830         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6831         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6832         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6833         { } /* end */
6834 };
6835
6836 /*
6837  * 6ch mode
6838  */
6839 static struct hda_verb alc883_4ST_ch6_init[] = {
6840         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6841         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6842         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6843         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6844         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6845         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6846         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6847         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6848         { } /* end */
6849 };
6850
6851 /*
6852  * 8ch mode
6853  */
6854 static struct hda_verb alc883_4ST_ch8_init[] = {
6855         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6856         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6857         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6858         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6859         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6860         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6861         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6862         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6863         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6864         { } /* end */
6865 };
6866
6867 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
6868         { 2, alc883_4ST_ch2_init },
6869         { 4, alc883_4ST_ch4_init },
6870         { 6, alc883_4ST_ch6_init },
6871         { 8, alc883_4ST_ch8_init },
6872 };
6873
6874
6875 /*
6876  * 2ch mode
6877  */
6878 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
6879         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6880         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6881         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6882         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6883         { } /* end */
6884 };
6885
6886 /*
6887  * 4ch mode
6888  */
6889 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
6890         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6891         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6892         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6893         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6894         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6895         { } /* end */
6896 };
6897
6898 /*
6899  * 6ch mode
6900  */
6901 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
6902         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6903         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6904         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
6905         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6906         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6907         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6908         { } /* end */
6909 };
6910
6911 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
6912         { 2, alc883_3ST_ch2_intel_init },
6913         { 4, alc883_3ST_ch4_intel_init },
6914         { 6, alc883_3ST_ch6_intel_init },
6915 };
6916
6917 /*
6918  * 2ch mode
6919  */
6920 static struct hda_verb alc889_ch2_intel_init[] = {
6921         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6922         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
6923         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
6924         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
6925         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6926         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6927         { } /* end */
6928 };
6929
6930 /*
6931  * 6ch mode
6932  */
6933 static struct hda_verb alc889_ch6_intel_init[] = {
6934         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6935         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6936         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6937         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6938         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6939         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6940         { } /* end */
6941 };
6942
6943 /*
6944  * 8ch mode
6945  */
6946 static struct hda_verb alc889_ch8_intel_init[] = {
6947         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
6948         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
6949         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
6950         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
6951         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
6952         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6953         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6954         { } /* end */
6955 };
6956
6957 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
6958         { 2, alc889_ch2_intel_init },
6959         { 6, alc889_ch6_intel_init },
6960         { 8, alc889_ch8_intel_init },
6961 };
6962
6963 /*
6964  * 6ch mode
6965  */
6966 static struct hda_verb alc883_sixstack_ch6_init[] = {
6967         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
6968         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6969         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6970         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6971         { } /* end */
6972 };
6973
6974 /*
6975  * 8ch mode
6976  */
6977 static struct hda_verb alc883_sixstack_ch8_init[] = {
6978         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6979         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6980         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6981         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6982         { } /* end */
6983 };
6984
6985 static struct hda_channel_mode alc883_sixstack_modes[2] = {
6986         { 6, alc883_sixstack_ch6_init },
6987         { 8, alc883_sixstack_ch8_init },
6988 };
6989
6990
6991 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
6992  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
6993  */
6994 static struct snd_kcontrol_new alc882_base_mixer[] = {
6995         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
6996         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
6997         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
6998         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
6999         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7000         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7001         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7002         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7003         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7004         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7005         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7006         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7007         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7008         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7009         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7010         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7011         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7012         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7013         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7014         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7015         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7016         { } /* end */
7017 };
7018
7019 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7020         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7021         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7022         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7023         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7024         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7025         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7026         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7027         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7028         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7029         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7030         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7031         { } /* end */
7032 };
7033
7034 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7035         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7036         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7037         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7038         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7039         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7040         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7041         HDA_CODEC_VOLUME("HP Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7042         HDA_BIND_MUTE   ("HP Playback Switch", 0x0f, 0x02, HDA_INPUT),
7043         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7044         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7045         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7046         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7047         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7048         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7049         { } /* end */
7050 };
7051
7052 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7053         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7054         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7055         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7056         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7057         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7058         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7059         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7060         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7061         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7062         { } /* end */
7063 };
7064
7065 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7066         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7067         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7068         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7069         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7070         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7071         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7072         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7073         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7074         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7075         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7076         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7077         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7078         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7079         { } /* end */
7080 };
7081
7082 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7083  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7084  */
7085 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7086         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7087         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7088         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7089         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7090         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7091         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7092         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7093         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7094         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7095         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7096         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7097         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7098         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7099         { } /* end */
7100 };
7101
7102 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7103         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7104         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7105         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7108         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7109         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7110         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7111         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7112         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7113         { } /* end */
7114 };
7115
7116 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7117         {
7118                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7119                 .name = "Channel Mode",
7120                 .info = alc_ch_mode_info,
7121                 .get = alc_ch_mode_get,
7122                 .put = alc_ch_mode_put,
7123         },
7124         { } /* end */
7125 };
7126
7127 static struct hda_verb alc882_base_init_verbs[] = {
7128         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7129         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7130         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7131         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7132         /* Rear mixer */
7133         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7134         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7135         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7136         /* CLFE mixer */
7137         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7138         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7139         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7140         /* Side mixer */
7141         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7142         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7143         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7144
7145         /* mute analog input loopbacks */
7146         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7147         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7148         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7149         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7150         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7151
7152         /* Front Pin: output 0 (0x0c) */
7153         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7154         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7155         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7156         /* Rear Pin: output 1 (0x0d) */
7157         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7158         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7159         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7160         /* CLFE Pin: output 2 (0x0e) */
7161         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7162         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7163         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7164         /* Side Pin: output 3 (0x0f) */
7165         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7166         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7167         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7168         /* Mic (rear) pin: input vref at 80% */
7169         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7170         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7171         /* Front Mic pin: input vref at 80% */
7172         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7173         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7174         /* Line In pin: input */
7175         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7176         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7177         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7178         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7179         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7180         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7181         /* CD pin widget for input */
7182         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7183
7184         /* FIXME: use matrix-type input source selection */
7185         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7186         /* Input mixer2 */
7187         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7188         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7189         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7190         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7191         /* Input mixer3 */
7192         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7193         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7194         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7195         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7196         /* ADC2: mute amp left and right */
7197         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7198         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7199         /* ADC3: mute amp left and right */
7200         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7201         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7202
7203         { }
7204 };
7205
7206 static struct hda_verb alc882_adc1_init_verbs[] = {
7207         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7208         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7209         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7210         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7211         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7212         /* ADC1: mute amp left and right */
7213         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7214         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7215         { }
7216 };
7217
7218 static struct hda_verb alc882_eapd_verbs[] = {
7219         /* change to EAPD mode */
7220         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7221         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7222         { }
7223 };
7224
7225 static struct hda_verb alc889_eapd_verbs[] = {
7226         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7227         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7228         { }
7229 };
7230
7231 static struct hda_verb alc_hp15_unsol_verbs[] = {
7232         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7233         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7234         {}
7235 };
7236
7237 static struct hda_verb alc885_init_verbs[] = {
7238         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7239         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7240         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7241         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7242         /* Rear mixer */
7243         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7244         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7245         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7246         /* CLFE mixer */
7247         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7248         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7249         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7250         /* Side mixer */
7251         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7252         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7253         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7254
7255         /* mute analog input loopbacks */
7256         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7257         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7258         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7259
7260         /* Front HP Pin: output 0 (0x0c) */
7261         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7262         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7263         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7264         /* Front Pin: output 0 (0x0c) */
7265         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7266         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7267         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7268         /* Rear Pin: output 1 (0x0d) */
7269         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7270         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7271         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7272         /* CLFE Pin: output 2 (0x0e) */
7273         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7274         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7275         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7276         /* Side Pin: output 3 (0x0f) */
7277         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7278         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7279         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7280         /* Mic (rear) pin: input vref at 80% */
7281         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7282         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7283         /* Front Mic pin: input vref at 80% */
7284         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7285         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7286         /* Line In pin: input */
7287         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7288         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7289
7290         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7291         /* Input mixer1 */
7292         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7293         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7294         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7295         /* Input mixer2 */
7296         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7297         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7298         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7299         /* Input mixer3 */
7300         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7301         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7302         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7303         /* ADC2: mute amp left and right */
7304         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7305         /* ADC3: mute amp left and right */
7306         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7307
7308         { }
7309 };
7310
7311 static struct hda_verb alc885_init_input_verbs[] = {
7312         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7313         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7314         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7315         { }
7316 };
7317
7318
7319 /* Unmute Selector 24h and set the default input to front mic */
7320 static struct hda_verb alc889_init_input_verbs[] = {
7321         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7322         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7323         { }
7324 };
7325
7326
7327 #define alc883_init_verbs       alc882_base_init_verbs
7328
7329 /* Mac Pro test */
7330 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7331         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7332         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7333         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7334         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7335         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7336         /* FIXME: this looks suspicious...
7337         HDA_CODEC_VOLUME("PC Speaker Playback Volume", 0x0b, 0x02, HDA_INPUT),
7338         HDA_CODEC_MUTE("PC Speaker Playback Switch", 0x0b, 0x02, HDA_INPUT),
7339         */
7340         { } /* end */
7341 };
7342
7343 static struct hda_verb alc882_macpro_init_verbs[] = {
7344         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7345         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7346         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7347         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7348         /* Front Pin: output 0 (0x0c) */
7349         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7350         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7351         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7352         /* Front Mic pin: input vref at 80% */
7353         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7354         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7355         /* Speaker:  output */
7356         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7357         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7358         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7359         /* Headphone output (output 0 - 0x0c) */
7360         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7361         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7362         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7363
7364         /* FIXME: use matrix-type input source selection */
7365         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7366         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7367         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7368         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7369         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7370         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7371         /* Input mixer2 */
7372         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7373         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7374         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7375         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7376         /* Input mixer3 */
7377         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7378         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7379         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7380         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7381         /* ADC1: mute amp left and right */
7382         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7383         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7384         /* ADC2: mute amp left and right */
7385         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7386         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7387         /* ADC3: mute amp left and right */
7388         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7389         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7390
7391         { }
7392 };
7393
7394 /* Macbook 5,1 */
7395 static struct hda_verb alc885_mb5_init_verbs[] = {
7396         /* DACs */
7397         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7398         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7399         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7400         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7401         /* Front mixer */
7402         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7403         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7404         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7405         /* Surround mixer */
7406         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7407         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7408         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7409         /* LFE mixer */
7410         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7411         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7412         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7413         /* HP mixer */
7414         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7415         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7416         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7417         /* Front Pin (0x0c) */
7418         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7419         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7420         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7421         /* LFE Pin (0x0e) */
7422         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7423         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7424         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7425         /* HP Pin (0x0f) */
7426         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7427         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7428         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7429         /* Front Mic pin: input vref at 80% */
7430         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7431         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7432         /* Line In pin */
7433         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7434         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7435
7436         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7437         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7438         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7439         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7440         { }
7441 };
7442
7443 /* Macbook Pro rev3 */
7444 static struct hda_verb alc885_mbp3_init_verbs[] = {
7445         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7446         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7447         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7448         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7449         /* Rear mixer */
7450         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7451         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7452         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7453         /* HP mixer */
7454         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7455         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7456         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7457         /* Front Pin: output 0 (0x0c) */
7458         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7459         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7460         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7461         /* HP Pin: output 0 (0x0e) */
7462         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7463         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7464         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7465         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7466         /* Mic (rear) pin: input vref at 80% */
7467         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7468         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7469         /* Front Mic pin: input vref at 80% */
7470         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7471         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7472         /* Line In pin: use output 1 when in LineOut mode */
7473         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7474         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7475         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7476
7477         /* FIXME: use matrix-type input source selection */
7478         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7479         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7480         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7481         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7482         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7483         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7484         /* Input mixer2 */
7485         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7486         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7487         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7488         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7489         /* Input mixer3 */
7490         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7491         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7492         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7493         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7494         /* ADC1: mute amp left and right */
7495         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7496         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7497         /* ADC2: mute amp left and right */
7498         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7499         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7500         /* ADC3: mute amp left and right */
7501         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7502         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7503
7504         { }
7505 };
7506
7507 /* iMac 24 mixer. */
7508 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7509         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7510         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7511         { } /* end */
7512 };
7513
7514 /* iMac 24 init verbs. */
7515 static struct hda_verb alc885_imac24_init_verbs[] = {
7516         /* Internal speakers: output 0 (0x0c) */
7517         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7518         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7519         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7520         /* Internal speakers: output 0 (0x0c) */
7521         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7522         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7523         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7524         /* Headphone: output 0 (0x0c) */
7525         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7526         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7527         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7528         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7529         /* Front Mic: input vref at 80% */
7530         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7531         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7532         { }
7533 };
7534
7535 /* Toggle speaker-output according to the hp-jack state */
7536 static void alc885_imac24_setup(struct hda_codec *codec)
7537 {
7538         struct alc_spec *spec = codec->spec;
7539
7540         spec->autocfg.hp_pins[0] = 0x14;
7541         spec->autocfg.speaker_pins[0] = 0x18;
7542         spec->autocfg.speaker_pins[1] = 0x1a;
7543 }
7544
7545 static void alc885_mbp3_setup(struct hda_codec *codec)
7546 {
7547         struct alc_spec *spec = codec->spec;
7548
7549         spec->autocfg.hp_pins[0] = 0x15;
7550         spec->autocfg.speaker_pins[0] = 0x14;
7551 }
7552
7553
7554 static struct hda_verb alc882_targa_verbs[] = {
7555         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7556         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7557
7558         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7559         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7560
7561         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7562         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7563         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7564
7565         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7566         { } /* end */
7567 };
7568
7569 /* toggle speaker-output according to the hp-jack state */
7570 static void alc882_targa_automute(struct hda_codec *codec)
7571 {
7572         struct alc_spec *spec = codec->spec;
7573         alc_automute_amp(codec);
7574         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
7575                                   spec->jack_present ? 1 : 3);
7576 }
7577
7578 static void alc882_targa_setup(struct hda_codec *codec)
7579 {
7580         struct alc_spec *spec = codec->spec;
7581
7582         spec->autocfg.hp_pins[0] = 0x14;
7583         spec->autocfg.speaker_pins[0] = 0x1b;
7584 }
7585
7586 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
7587 {
7588         if ((res >> 26) == ALC880_HP_EVENT)
7589                 alc882_targa_automute(codec);
7590 }
7591
7592 static struct hda_verb alc882_asus_a7j_verbs[] = {
7593         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7594         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7595
7596         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7597         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7598         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7599
7600         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7601         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7602         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7603
7604         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7605         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7606         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7607         { } /* end */
7608 };
7609
7610 static struct hda_verb alc882_asus_a7m_verbs[] = {
7611         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7612         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7613
7614         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7615         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7616         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7617
7618         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7619         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7620         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
7621
7622         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
7623         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
7624         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
7625         { } /* end */
7626 };
7627
7628 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
7629 {
7630         unsigned int gpiostate, gpiomask, gpiodir;
7631
7632         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
7633                                        AC_VERB_GET_GPIO_DATA, 0);
7634
7635         if (!muted)
7636                 gpiostate |= (1 << pin);
7637         else
7638                 gpiostate &= ~(1 << pin);
7639
7640         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
7641                                       AC_VERB_GET_GPIO_MASK, 0);
7642         gpiomask |= (1 << pin);
7643
7644         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
7645                                      AC_VERB_GET_GPIO_DIRECTION, 0);
7646         gpiodir |= (1 << pin);
7647
7648
7649         snd_hda_codec_write(codec, codec->afg, 0,
7650                             AC_VERB_SET_GPIO_MASK, gpiomask);
7651         snd_hda_codec_write(codec, codec->afg, 0,
7652                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
7653
7654         msleep(1);
7655
7656         snd_hda_codec_write(codec, codec->afg, 0,
7657                             AC_VERB_SET_GPIO_DATA, gpiostate);
7658 }
7659
7660 /* set up GPIO at initialization */
7661 static void alc885_macpro_init_hook(struct hda_codec *codec)
7662 {
7663         alc882_gpio_mute(codec, 0, 0);
7664         alc882_gpio_mute(codec, 1, 0);
7665 }
7666
7667 /* set up GPIO and update auto-muting at initialization */
7668 static void alc885_imac24_init_hook(struct hda_codec *codec)
7669 {
7670         alc885_macpro_init_hook(codec);
7671         alc_automute_amp(codec);
7672 }
7673
7674 /*
7675  * generic initialization of ADC, input mixers and output mixers
7676  */
7677 static struct hda_verb alc883_auto_init_verbs[] = {
7678         /*
7679          * Unmute ADC0-2 and set the default input to mic-in
7680          */
7681         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7682         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7683         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7684         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7685
7686         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
7687          * mixer widget
7688          * Note: PASD motherboards uses the Line In 2 as the input for
7689          * front panel mic (mic 2)
7690          */
7691         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
7692         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7693         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7694         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7695         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7696         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7697
7698         /*
7699          * Set up output mixers (0x0c - 0x0f)
7700          */
7701         /* set vol=0 to output mixers */
7702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7703         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7704         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7705         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7706         /* set up input amps for analog loopback */
7707         /* Amp Indices: DAC = 0, mixer = 1 */
7708         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7709         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7710         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7711         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7712         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7713         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7714         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7715         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7716         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7717         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7718
7719         /* FIXME: use matrix-type input source selection */
7720         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7721         /* Input mixer2 */
7722         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7723         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7724         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7725         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7726         /* Input mixer3 */
7727         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
7728         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
7729         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
7730         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
7731
7732         { }
7733 };
7734
7735 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
7736 static struct hda_verb alc889A_mb31_ch2_init[] = {
7737         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7738         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7739         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7740         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7741         { } /* end */
7742 };
7743
7744 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
7745 static struct hda_verb alc889A_mb31_ch4_init[] = {
7746         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
7747         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7748         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7750         { } /* end */
7751 };
7752
7753 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
7754 static struct hda_verb alc889A_mb31_ch5_init[] = {
7755         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
7756         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
7757         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
7758         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
7759         { } /* end */
7760 };
7761
7762 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
7763 static struct hda_verb alc889A_mb31_ch6_init[] = {
7764         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
7765         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
7766         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
7767         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
7768         { } /* end */
7769 };
7770
7771 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
7772         { 2, alc889A_mb31_ch2_init },
7773         { 4, alc889A_mb31_ch4_init },
7774         { 5, alc889A_mb31_ch5_init },
7775         { 6, alc889A_mb31_ch6_init },
7776 };
7777
7778 static struct hda_verb alc883_medion_eapd_verbs[] = {
7779         /* eanable EAPD on medion laptop */
7780         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7781         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
7782         { }
7783 };
7784
7785 #define alc883_base_mixer       alc882_base_mixer
7786
7787 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
7788         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7789         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7790         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7791         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7792         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7793         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7794         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7795         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7796         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7798         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7799         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7800         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7801         { } /* end */
7802 };
7803
7804 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
7805         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7806         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7807         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7808         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7809         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7810         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7811         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7812         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7813         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7814         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7815         { } /* end */
7816 };
7817
7818 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
7819         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7820         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
7821         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7822         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7823         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7824         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7825         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7826         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7827         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7828         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7829         { } /* end */
7830 };
7831
7832 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
7833         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7834         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7835         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7836         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7837         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7838         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7839         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7840         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7841         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7842         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7843         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7844         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7845         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7846         { } /* end */
7847 };
7848
7849 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
7850         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7851         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7852         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7853         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7854         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7855         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7856         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7857         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7858         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7859         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7860         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7861         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7862         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7863         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7864         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7865         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7866         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7867         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7868         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7869         { } /* end */
7870 };
7871
7872 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
7873         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7874         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7875         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7876         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7877         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7878                               HDA_OUTPUT),
7879         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7880         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7881         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7882         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7883         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7884         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7885         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7886         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7887         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7888         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
7889         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7890         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7891         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7892         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7893         { } /* end */
7894 };
7895
7896 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
7897         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7898         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7899         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7900         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7901         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
7902                               HDA_OUTPUT),
7903         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7904         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7905         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7906         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7907         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
7908         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7909         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7910         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7911         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
7912         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
7913         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
7914         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7915         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
7916         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7917         { } /* end */
7918 };
7919
7920 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
7921         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7922         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7923         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7924         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7925         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7926         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7927         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7928         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7929         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7930         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7931         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7932         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7933         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7934         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7935         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7936         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7937         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7938         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7939         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7940         { } /* end */
7941 };
7942
7943 static struct snd_kcontrol_new alc883_targa_mixer[] = {
7944         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7945         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7946         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7947         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7948         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7949         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7950         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7951         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7952         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7953         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7954         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7955         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7956         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7957         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7958         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7959         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7960         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7961         { } /* end */
7962 };
7963
7964 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
7965         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7966         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7967         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7968         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7969         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7970         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7971         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7972         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7973         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7974         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7975         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7976         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7977         { } /* end */
7978 };
7979
7980 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
7981         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7982         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7983         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7984         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
7985         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7986         { } /* end */
7987 };
7988
7989 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
7990         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7991         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7992         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7993         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
7994         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7996         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7997         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7998         { } /* end */
7999 };
8000
8001 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8002         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8003         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8004         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8005         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8006         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8007         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8008         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8009         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8010         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8011         { } /* end */
8012 };
8013
8014 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8015         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8016         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8017         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8018         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8019         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8020         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8021         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8022         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8023         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8024         { } /* end */
8025 };
8026
8027 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8028         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8029         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8030         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8031         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8032         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8033         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8034         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8035         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8036         { } /* end */
8037 };
8038
8039 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8040         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8041         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8042         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8043         HDA_BIND_MUTE("LFE Playback Switch", 0x0f, 2, HDA_INPUT),
8044         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8045         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
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("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8049         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8050         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8051         { } /* end */
8052 };
8053
8054 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8055         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8056         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8057         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8058         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8059         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8060                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8061         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8062         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8063         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8064         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8065         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8066         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8067         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8068         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8069         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8070         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8071         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8072         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8073         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8074         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8075         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8076         { } /* end */
8077 };
8078
8079 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8080         /* Output mixers */
8081         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8082         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8083         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8084         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8085         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8086                 HDA_OUTPUT),
8087         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8088         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8089         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8090         /* Output switches */
8091         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8092         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8093         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8094         /* Boost mixers */
8095         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8096         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8097         /* Input mixers */
8098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8099         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8100         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8101         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8102         { } /* end */
8103 };
8104
8105 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8106         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8107         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8108         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8109         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8110         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8111         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8112         { } /* end */
8113 };
8114
8115 static struct hda_bind_ctls alc883_bind_cap_vol = {
8116         .ops = &snd_hda_bind_vol,
8117         .values = {
8118                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8119                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8120                 0
8121         },
8122 };
8123
8124 static struct hda_bind_ctls alc883_bind_cap_switch = {
8125         .ops = &snd_hda_bind_sw,
8126         .values = {
8127                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8128                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8129                 0
8130         },
8131 };
8132
8133 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8134         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8135         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8136         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8137         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8138         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8139         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8140         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8141         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8142         { } /* end */
8143 };
8144
8145 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8146         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8147         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8148         {
8149                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8150                 /* .name = "Capture Source", */
8151                 .name = "Input Source",
8152                 .count = 1,
8153                 .info = alc_mux_enum_info,
8154                 .get = alc_mux_enum_get,
8155                 .put = alc_mux_enum_put,
8156         },
8157         { } /* end */
8158 };
8159
8160 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8161         {
8162                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8163                 .name = "Channel Mode",
8164                 .info = alc_ch_mode_info,
8165                 .get = alc_ch_mode_get,
8166                 .put = alc_ch_mode_put,
8167         },
8168         { } /* end */
8169 };
8170
8171 /* toggle speaker-output according to the hp-jack state */
8172 static void alc883_mitac_setup(struct hda_codec *codec)
8173 {
8174         struct alc_spec *spec = codec->spec;
8175
8176         spec->autocfg.hp_pins[0] = 0x15;
8177         spec->autocfg.speaker_pins[0] = 0x14;
8178         spec->autocfg.speaker_pins[1] = 0x17;
8179 }
8180
8181 /* auto-toggle front mic */
8182 /*
8183 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8184 {
8185         unsigned int present;
8186         unsigned char bits;
8187
8188         present = snd_hda_codec_read(codec, 0x18, 0,
8189                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8190         bits = present ? HDA_AMP_MUTE : 0;
8191         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8192 }
8193 */
8194
8195 static struct hda_verb alc883_mitac_verbs[] = {
8196         /* HP */
8197         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8198         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8199         /* Subwoofer */
8200         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8201         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8202
8203         /* enable unsolicited event */
8204         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8205         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8206
8207         { } /* end */
8208 };
8209
8210 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8211         /* HP */
8212         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8213         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8214         /* Int speaker */
8215         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8216
8217         /* enable unsolicited event */
8218         /*
8219         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8220         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8221         */
8222
8223         { } /* end */
8224 };
8225
8226 static struct hda_verb alc883_clevo_m720_verbs[] = {
8227         /* HP */
8228         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8229         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8230         /* Int speaker */
8231         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8232         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8233
8234         /* enable unsolicited event */
8235         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8236         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8237
8238         { } /* end */
8239 };
8240
8241 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8242         /* HP */
8243         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8244         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8245         /* Subwoofer */
8246         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8247         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8248
8249         /* enable unsolicited event */
8250         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8251
8252         { } /* end */
8253 };
8254
8255 static struct hda_verb alc883_targa_verbs[] = {
8256         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8257         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8258
8259         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8260         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8261
8262 /* Connect Line-Out side jack (SPDIF) to Side */
8263         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8264         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8265         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8266 /* Connect Mic jack to CLFE */
8267         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8268         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8269         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8270 /* Connect Line-in jack to Surround */
8271         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8272         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8273         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8274 /* Connect HP out jack to Front */
8275         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8276         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8277         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8278
8279         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8280
8281         { } /* end */
8282 };
8283
8284 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8285         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8286         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8287         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8288         { } /* end */
8289 };
8290
8291 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8292         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8293         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8294         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8295         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8296         { } /* end */
8297 };
8298
8299 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8300         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8301         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8302         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8303         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8304         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8305         { } /* end */
8306 };
8307
8308 static struct hda_verb alc883_haier_w66_verbs[] = {
8309         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8310         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8311
8312         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8313
8314         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8315         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8316         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8317         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8318         { } /* end */
8319 };
8320
8321 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8322         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8323         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8324         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8325         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8326         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8327         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8328         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8329         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8330         { } /* end */
8331 };
8332
8333 static struct hda_verb alc888_6st_dell_verbs[] = {
8334         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8335         { }
8336 };
8337
8338 static struct hda_verb alc883_vaiott_verbs[] = {
8339         /* HP */
8340         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8341         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8342
8343         /* enable unsolicited event */
8344         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8345
8346         { } /* end */
8347 };
8348
8349 static void alc888_3st_hp_setup(struct hda_codec *codec)
8350 {
8351         struct alc_spec *spec = codec->spec;
8352
8353         spec->autocfg.hp_pins[0] = 0x1b;
8354         spec->autocfg.speaker_pins[0] = 0x14;
8355         spec->autocfg.speaker_pins[1] = 0x16;
8356         spec->autocfg.speaker_pins[2] = 0x18;
8357 }
8358
8359 static struct hda_verb alc888_3st_hp_verbs[] = {
8360         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8361         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8362         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8363         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8364         { } /* end */
8365 };
8366
8367 /*
8368  * 2ch mode
8369  */
8370 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8371         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8372         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8373         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8374         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8375         { } /* end */
8376 };
8377
8378 /*
8379  * 4ch mode
8380  */
8381 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8382         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8383         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8384         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8385         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8386         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8387         { } /* end */
8388 };
8389
8390 /*
8391  * 6ch mode
8392  */
8393 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8394         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8395         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8396         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8397         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8398         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8399         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8400         { } /* end */
8401 };
8402
8403 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8404         { 2, alc888_3st_hp_2ch_init },
8405         { 4, alc888_3st_hp_4ch_init },
8406         { 6, alc888_3st_hp_6ch_init },
8407 };
8408
8409 /* toggle front-jack and RCA according to the hp-jack state */
8410 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8411 {
8412         unsigned int present;
8413
8414         present = snd_hda_codec_read(codec, 0x1b, 0,
8415                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8416         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8417                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8418         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8419                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8420 }
8421
8422 /* toggle RCA according to the front-jack state */
8423 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8424 {
8425         unsigned int present;
8426
8427         present = snd_hda_codec_read(codec, 0x14, 0,
8428                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8429         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8430                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8431 }
8432
8433 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8434                                              unsigned int res)
8435 {
8436         if ((res >> 26) == ALC880_HP_EVENT)
8437                 alc888_lenovo_ms7195_front_automute(codec);
8438         if ((res >> 26) == ALC880_FRONT_EVENT)
8439                 alc888_lenovo_ms7195_rca_automute(codec);
8440 }
8441
8442 static struct hda_verb alc883_medion_md2_verbs[] = {
8443         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8444         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8445
8446         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8447
8448         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8449         { } /* end */
8450 };
8451
8452 /* toggle speaker-output according to the hp-jack state */
8453 static void alc883_medion_md2_setup(struct hda_codec *codec)
8454 {
8455         struct alc_spec *spec = codec->spec;
8456
8457         spec->autocfg.hp_pins[0] = 0x14;
8458         spec->autocfg.speaker_pins[0] = 0x15;
8459 }
8460
8461 /* toggle speaker-output according to the hp-jack state */
8462 #define alc883_targa_init_hook          alc882_targa_init_hook
8463 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8464
8465 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8466 {
8467         unsigned int present;
8468
8469         present = snd_hda_codec_read(codec, 0x18, 0,
8470                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8471         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8472                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8473 }
8474
8475 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8476 {
8477         struct alc_spec *spec = codec->spec;
8478
8479         spec->autocfg.hp_pins[0] = 0x15;
8480         spec->autocfg.speaker_pins[0] = 0x14;
8481 }
8482
8483 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8484 {
8485         alc_automute_amp(codec);
8486         alc883_clevo_m720_mic_automute(codec);
8487 }
8488
8489 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8490                                            unsigned int res)
8491 {
8492         switch (res >> 26) {
8493         case ALC880_MIC_EVENT:
8494                 alc883_clevo_m720_mic_automute(codec);
8495                 break;
8496         default:
8497                 alc_automute_amp_unsol_event(codec, res);
8498                 break;
8499         }
8500 }
8501
8502 /* toggle speaker-output according to the hp-jack state */
8503 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8504 {
8505         struct alc_spec *spec = codec->spec;
8506
8507         spec->autocfg.hp_pins[0] = 0x14;
8508         spec->autocfg.speaker_pins[0] = 0x15;
8509 }
8510
8511 static void alc883_haier_w66_setup(struct hda_codec *codec)
8512 {
8513         struct alc_spec *spec = codec->spec;
8514
8515         spec->autocfg.hp_pins[0] = 0x1b;
8516         spec->autocfg.speaker_pins[0] = 0x14;
8517 }
8518
8519 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8520 {
8521         unsigned int present;
8522         unsigned char bits;
8523
8524         present = snd_hda_codec_read(codec, 0x14, 0, AC_VERB_GET_PIN_SENSE, 0)
8525                 & AC_PINSENSE_PRESENCE;
8526         bits = present ? HDA_AMP_MUTE : 0;
8527         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8528                                  HDA_AMP_MUTE, bits);
8529 }
8530
8531 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8532 {
8533         unsigned int present;
8534         unsigned char bits;
8535
8536         present = snd_hda_codec_read(codec, 0x1b, 0,
8537                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
8538         bits = present ? HDA_AMP_MUTE : 0;
8539         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8540                                  HDA_AMP_MUTE, bits);
8541         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8542                                  HDA_AMP_MUTE, bits);
8543 }
8544
8545 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8546                                            unsigned int res)
8547 {
8548         if ((res >> 26) == ALC880_HP_EVENT)
8549                 alc883_lenovo_101e_all_automute(codec);
8550         if ((res >> 26) == ALC880_FRONT_EVENT)
8551                 alc883_lenovo_101e_ispeaker_automute(codec);
8552 }
8553
8554 /* toggle speaker-output according to the hp-jack state */
8555 static void alc883_acer_aspire_setup(struct hda_codec *codec)
8556 {
8557         struct alc_spec *spec = codec->spec;
8558
8559         spec->autocfg.hp_pins[0] = 0x14;
8560         spec->autocfg.speaker_pins[0] = 0x15;
8561         spec->autocfg.speaker_pins[1] = 0x16;
8562 }
8563
8564 static struct hda_verb alc883_acer_eapd_verbs[] = {
8565         /* HP Pin: output 0 (0x0c) */
8566         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8567         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8568         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8569         /* Front Pin: output 0 (0x0c) */
8570         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8571         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8572         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8573         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
8574         /* eanable EAPD on medion laptop */
8575         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8576         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
8577         /* enable unsolicited event */
8578         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8579         { }
8580 };
8581
8582 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
8583         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8584         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8585         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8586         { } /* end */
8587 };
8588
8589 static void alc888_6st_dell_setup(struct hda_codec *codec)
8590 {
8591         struct alc_spec *spec = codec->spec;
8592
8593         spec->autocfg.hp_pins[0] = 0x1b;
8594         spec->autocfg.speaker_pins[0] = 0x14;
8595         spec->autocfg.speaker_pins[1] = 0x15;
8596         spec->autocfg.speaker_pins[2] = 0x16;
8597         spec->autocfg.speaker_pins[3] = 0x17;
8598 }
8599
8600 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
8601 {
8602         struct alc_spec *spec = codec->spec;
8603
8604         spec->autocfg.hp_pins[0] = 0x1b;
8605         spec->autocfg.speaker_pins[0] = 0x14;
8606         spec->autocfg.speaker_pins[1] = 0x15;
8607         spec->autocfg.speaker_pins[2] = 0x16;
8608         spec->autocfg.speaker_pins[3] = 0x17;
8609         spec->autocfg.speaker_pins[4] = 0x1a;
8610 }
8611
8612 static void alc883_vaiott_setup(struct hda_codec *codec)
8613 {
8614         struct alc_spec *spec = codec->spec;
8615
8616         spec->autocfg.hp_pins[0] = 0x15;
8617         spec->autocfg.speaker_pins[0] = 0x14;
8618         spec->autocfg.speaker_pins[1] = 0x17;
8619 }
8620
8621 static struct hda_verb alc888_asus_m90v_verbs[] = {
8622         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8623         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8624         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8625         /* enable unsolicited event */
8626         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8627         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8628         { } /* end */
8629 };
8630
8631 static void alc883_mode2_setup(struct hda_codec *codec)
8632 {
8633         struct alc_spec *spec = codec->spec;
8634
8635         spec->autocfg.hp_pins[0] = 0x1b;
8636         spec->autocfg.speaker_pins[0] = 0x14;
8637         spec->autocfg.speaker_pins[1] = 0x15;
8638         spec->autocfg.speaker_pins[2] = 0x16;
8639         spec->ext_mic.pin = 0x18;
8640         spec->int_mic.pin = 0x19;
8641         spec->ext_mic.mux_idx = 0;
8642         spec->int_mic.mux_idx = 1;
8643         spec->auto_mic = 1;
8644 }
8645
8646 static struct hda_verb alc888_asus_eee1601_verbs[] = {
8647         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8648         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8649         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
8650         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8651         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
8652         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
8653         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
8654         /* enable unsolicited event */
8655         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8656         { } /* end */
8657 };
8658
8659 static void alc883_eee1601_inithook(struct hda_codec *codec)
8660 {
8661         struct alc_spec *spec = codec->spec;
8662
8663         spec->autocfg.hp_pins[0] = 0x14;
8664         spec->autocfg.speaker_pins[0] = 0x1b;
8665         alc_automute_pin(codec);
8666 }
8667
8668 static struct hda_verb alc889A_mb31_verbs[] = {
8669         /* Init rear pin (used as headphone output) */
8670         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
8671         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
8672         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8673         /* Init line pin (used as output in 4ch and 6ch mode) */
8674         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
8675         /* Init line 2 pin (used as headphone out by default) */
8676         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
8677         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
8678         { } /* end */
8679 };
8680
8681 /* Mute speakers according to the headphone jack state */
8682 static void alc889A_mb31_automute(struct hda_codec *codec)
8683 {
8684         unsigned int present;
8685
8686         /* Mute only in 2ch or 4ch mode */
8687         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
8688             == 0x00) {
8689                 present = snd_hda_codec_read(codec, 0x15, 0,
8690                         AC_VERB_GET_PIN_SENSE, 0) & AC_PINSENSE_PRESENCE;
8691                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
8692                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8693                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
8694                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8695         }
8696 }
8697
8698 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
8699 {
8700         if ((res >> 26) == ALC880_HP_EVENT)
8701                 alc889A_mb31_automute(codec);
8702 }
8703
8704
8705 #ifdef CONFIG_SND_HDA_POWER_SAVE
8706 #define alc882_loopbacks        alc880_loopbacks
8707 #endif
8708
8709 /* pcm configuration: identical with ALC880 */
8710 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
8711 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
8712 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
8713 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
8714
8715 static hda_nid_t alc883_slave_dig_outs[] = {
8716         ALC1200_DIGOUT_NID, 0,
8717 };
8718
8719 static hda_nid_t alc1200_slave_dig_outs[] = {
8720         ALC883_DIGOUT_NID, 0,
8721 };
8722
8723 /*
8724  * configuration and preset
8725  */
8726 static const char *alc882_models[ALC882_MODEL_LAST] = {
8727         [ALC882_3ST_DIG]        = "3stack-dig",
8728         [ALC882_6ST_DIG]        = "6stack-dig",
8729         [ALC882_ARIMA]          = "arima",
8730         [ALC882_W2JC]           = "w2jc",
8731         [ALC882_TARGA]          = "targa",
8732         [ALC882_ASUS_A7J]       = "asus-a7j",
8733         [ALC882_ASUS_A7M]       = "asus-a7m",
8734         [ALC885_MACPRO]         = "macpro",
8735         [ALC885_MB5]            = "mb5",
8736         [ALC885_MBP3]           = "mbp3",
8737         [ALC885_IMAC24]         = "imac24",
8738         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
8739         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
8740         [ALC883_3ST_6ch]        = "3stack-6ch",
8741         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
8742         [ALC883_TARGA_DIG]      = "targa-dig",
8743         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
8744         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
8745         [ALC883_ACER]           = "acer",
8746         [ALC883_ACER_ASPIRE]    = "acer-aspire",
8747         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
8748         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
8749         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
8750         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
8751         [ALC883_MEDION]         = "medion",
8752         [ALC883_MEDION_MD2]     = "medion-md2",
8753         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
8754         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
8755         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
8756         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
8757         [ALC888_LENOVO_SKY] = "lenovo-sky",
8758         [ALC883_HAIER_W66]      = "haier-w66",
8759         [ALC888_3ST_HP]         = "3stack-hp",
8760         [ALC888_6ST_DELL]       = "6stack-dell",
8761         [ALC883_MITAC]          = "mitac",
8762         [ALC883_CLEVO_M540R]    = "clevo-m540r",
8763         [ALC883_CLEVO_M720]     = "clevo-m720",
8764         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
8765         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
8766         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
8767         [ALC889A_INTEL]         = "intel-alc889a",
8768         [ALC889_INTEL]          = "intel-x58",
8769         [ALC1200_ASUS_P5Q]      = "asus-p5q",
8770         [ALC889A_MB31]          = "mb31",
8771         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
8772         [ALC882_AUTO]           = "auto",
8773 };
8774
8775 static struct snd_pci_quirk alc882_cfg_tbl[] = {
8776         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
8777
8778         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
8779         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
8780         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
8781         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
8782         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
8783         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
8784         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
8785                 ALC888_ACER_ASPIRE_4930G),
8786         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
8787                 ALC888_ACER_ASPIRE_4930G),
8788         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
8789                 ALC888_ACER_ASPIRE_8930G),
8790         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
8791                 ALC888_ACER_ASPIRE_8930G),
8792         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
8793         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
8794         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
8795                 ALC888_ACER_ASPIRE_6530G),
8796         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
8797                 ALC888_ACER_ASPIRE_6530G),
8798         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
8799                 ALC888_ACER_ASPIRE_7730G),
8800         /* default Acer -- disabled as it causes more problems.
8801          *    model=auto should work fine now
8802          */
8803         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
8804
8805         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
8806
8807         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
8808         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
8809         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
8810         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
8811         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
8812         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
8813
8814         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
8815         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
8816         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
8817         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
8818         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
8819         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
8820         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
8821         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
8822         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
8823         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
8824         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
8825
8826         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
8827         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
8828         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
8829         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
8830         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
8831         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
8832         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
8833         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
8834         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
8835
8836         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
8837         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
8838         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
8839         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
8840         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC883_TARGA_2ch_DIG),
8841         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
8842         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
8843         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
8844         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
8845         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
8846         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
8847         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
8848         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
8849         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
8850         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
8851         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
8852         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
8853         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
8854         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
8855         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
8856         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
8857         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
8858         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
8859         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
8860         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
8861         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
8862         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
8863         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
8864         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
8865
8866         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
8867         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
8868         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
8869         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
8870         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
8871         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
8872         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
8873         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
8874         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
8875                       ALC883_FUJITSU_PI2515),
8876         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
8877                 ALC888_FUJITSU_XA3530),
8878         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
8879         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8880         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8881         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
8882         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
8883         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
8884         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
8885         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
8886         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
8887
8888         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
8889         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
8890         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
8891         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
8892         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
8893         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
8894         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC883_3ST_6ch),
8895
8896         {}
8897 };
8898
8899 /* codec SSID table for Intel Mac */
8900 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
8901         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
8902         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
8903         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
8904         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
8905         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
8906         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
8907         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
8908         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
8909         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
8910         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
8911         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
8912         /* FIXME: HP jack sense seems not working for MBP 5,1, so apparently
8913          * no perfect solution yet
8914          */
8915         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
8916         {} /* terminator */
8917 };
8918
8919 static struct alc_config_preset alc882_presets[] = {
8920         [ALC882_3ST_DIG] = {
8921                 .mixers = { alc882_base_mixer },
8922                 .init_verbs = { alc882_base_init_verbs,
8923                                 alc882_adc1_init_verbs },
8924                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8925                 .dac_nids = alc882_dac_nids,
8926                 .dig_out_nid = ALC882_DIGOUT_NID,
8927                 .dig_in_nid = ALC882_DIGIN_NID,
8928                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
8929                 .channel_mode = alc882_ch_modes,
8930                 .need_dac_fix = 1,
8931                 .input_mux = &alc882_capture_source,
8932         },
8933         [ALC882_6ST_DIG] = {
8934                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8935                 .init_verbs = { alc882_base_init_verbs,
8936                                 alc882_adc1_init_verbs },
8937                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8938                 .dac_nids = alc882_dac_nids,
8939                 .dig_out_nid = ALC882_DIGOUT_NID,
8940                 .dig_in_nid = ALC882_DIGIN_NID,
8941                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8942                 .channel_mode = alc882_sixstack_modes,
8943                 .input_mux = &alc882_capture_source,
8944         },
8945         [ALC882_ARIMA] = {
8946                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
8947                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8948                                 alc882_eapd_verbs },
8949                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8950                 .dac_nids = alc882_dac_nids,
8951                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
8952                 .channel_mode = alc882_sixstack_modes,
8953                 .input_mux = &alc882_capture_source,
8954         },
8955         [ALC882_W2JC] = {
8956                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
8957                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
8958                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
8959                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8960                 .dac_nids = alc882_dac_nids,
8961                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
8962                 .channel_mode = alc880_threestack_modes,
8963                 .need_dac_fix = 1,
8964                 .input_mux = &alc882_capture_source,
8965                 .dig_out_nid = ALC882_DIGOUT_NID,
8966         },
8967         [ALC885_MBP3] = {
8968                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
8969                 .init_verbs = { alc885_mbp3_init_verbs,
8970                                 alc880_gpio1_init_verbs },
8971                 .num_dacs = 2,
8972                 .dac_nids = alc882_dac_nids,
8973                 .hp_nid = 0x04,
8974                 .channel_mode = alc885_mbp_4ch_modes,
8975                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
8976                 .input_mux = &alc882_capture_source,
8977                 .dig_out_nid = ALC882_DIGOUT_NID,
8978                 .dig_in_nid = ALC882_DIGIN_NID,
8979                 .unsol_event = alc_automute_amp_unsol_event,
8980                 .setup = alc885_mbp3_setup,
8981                 .init_hook = alc_automute_amp,
8982         },
8983         [ALC885_MB5] = {
8984                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
8985                 .init_verbs = { alc885_mb5_init_verbs,
8986                                 alc880_gpio1_init_verbs },
8987                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8988                 .dac_nids = alc882_dac_nids,
8989                 .channel_mode = alc885_mb5_6ch_modes,
8990                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
8991                 .input_mux = &mb5_capture_source,
8992                 .dig_out_nid = ALC882_DIGOUT_NID,
8993                 .dig_in_nid = ALC882_DIGIN_NID,
8994         },
8995         [ALC885_MACPRO] = {
8996                 .mixers = { alc882_macpro_mixer },
8997                 .init_verbs = { alc882_macpro_init_verbs },
8998                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
8999                 .dac_nids = alc882_dac_nids,
9000                 .dig_out_nid = ALC882_DIGOUT_NID,
9001                 .dig_in_nid = ALC882_DIGIN_NID,
9002                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9003                 .channel_mode = alc882_ch_modes,
9004                 .input_mux = &alc882_capture_source,
9005                 .init_hook = alc885_macpro_init_hook,
9006         },
9007         [ALC885_IMAC24] = {
9008                 .mixers = { alc885_imac24_mixer },
9009                 .init_verbs = { alc885_imac24_init_verbs },
9010                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9011                 .dac_nids = alc882_dac_nids,
9012                 .dig_out_nid = ALC882_DIGOUT_NID,
9013                 .dig_in_nid = ALC882_DIGIN_NID,
9014                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9015                 .channel_mode = alc882_ch_modes,
9016                 .input_mux = &alc882_capture_source,
9017                 .unsol_event = alc_automute_amp_unsol_event,
9018                 .setup = alc885_imac24_setup,
9019                 .init_hook = alc885_imac24_init_hook,
9020         },
9021         [ALC882_TARGA] = {
9022                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9023                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9024                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9025                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9026                 .dac_nids = alc882_dac_nids,
9027                 .dig_out_nid = ALC882_DIGOUT_NID,
9028                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9029                 .adc_nids = alc882_adc_nids,
9030                 .capsrc_nids = alc882_capsrc_nids,
9031                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9032                 .channel_mode = alc882_3ST_6ch_modes,
9033                 .need_dac_fix = 1,
9034                 .input_mux = &alc882_capture_source,
9035                 .unsol_event = alc882_targa_unsol_event,
9036                 .setup = alc882_targa_setup,
9037                 .init_hook = alc882_targa_automute,
9038         },
9039         [ALC882_ASUS_A7J] = {
9040                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9041                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9042                                 alc882_asus_a7j_verbs},
9043                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9044                 .dac_nids = alc882_dac_nids,
9045                 .dig_out_nid = ALC882_DIGOUT_NID,
9046                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9047                 .adc_nids = alc882_adc_nids,
9048                 .capsrc_nids = alc882_capsrc_nids,
9049                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9050                 .channel_mode = alc882_3ST_6ch_modes,
9051                 .need_dac_fix = 1,
9052                 .input_mux = &alc882_capture_source,
9053         },
9054         [ALC882_ASUS_A7M] = {
9055                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9056                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9057                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9058                                 alc882_asus_a7m_verbs },
9059                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9060                 .dac_nids = alc882_dac_nids,
9061                 .dig_out_nid = ALC882_DIGOUT_NID,
9062                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9063                 .channel_mode = alc880_threestack_modes,
9064                 .need_dac_fix = 1,
9065                 .input_mux = &alc882_capture_source,
9066         },
9067         [ALC883_3ST_2ch_DIG] = {
9068                 .mixers = { alc883_3ST_2ch_mixer },
9069                 .init_verbs = { alc883_init_verbs },
9070                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9071                 .dac_nids = alc883_dac_nids,
9072                 .dig_out_nid = ALC883_DIGOUT_NID,
9073                 .dig_in_nid = ALC883_DIGIN_NID,
9074                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9075                 .channel_mode = alc883_3ST_2ch_modes,
9076                 .input_mux = &alc883_capture_source,
9077         },
9078         [ALC883_3ST_6ch_DIG] = {
9079                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9080                 .init_verbs = { alc883_init_verbs },
9081                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9082                 .dac_nids = alc883_dac_nids,
9083                 .dig_out_nid = ALC883_DIGOUT_NID,
9084                 .dig_in_nid = ALC883_DIGIN_NID,
9085                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9086                 .channel_mode = alc883_3ST_6ch_modes,
9087                 .need_dac_fix = 1,
9088                 .input_mux = &alc883_capture_source,
9089         },
9090         [ALC883_3ST_6ch] = {
9091                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9092                 .init_verbs = { alc883_init_verbs },
9093                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9094                 .dac_nids = alc883_dac_nids,
9095                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9096                 .channel_mode = alc883_3ST_6ch_modes,
9097                 .need_dac_fix = 1,
9098                 .input_mux = &alc883_capture_source,
9099         },
9100         [ALC883_3ST_6ch_INTEL] = {
9101                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9102                 .init_verbs = { alc883_init_verbs },
9103                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9104                 .dac_nids = alc883_dac_nids,
9105                 .dig_out_nid = ALC883_DIGOUT_NID,
9106                 .dig_in_nid = ALC883_DIGIN_NID,
9107                 .slave_dig_outs = alc883_slave_dig_outs,
9108                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9109                 .channel_mode = alc883_3ST_6ch_intel_modes,
9110                 .need_dac_fix = 1,
9111                 .input_mux = &alc883_3stack_6ch_intel,
9112         },
9113         [ALC889A_INTEL] = {
9114                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9115                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9116                                 alc_hp15_unsol_verbs },
9117                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9118                 .dac_nids = alc883_dac_nids,
9119                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9120                 .adc_nids = alc889_adc_nids,
9121                 .dig_out_nid = ALC883_DIGOUT_NID,
9122                 .dig_in_nid = ALC883_DIGIN_NID,
9123                 .slave_dig_outs = alc883_slave_dig_outs,
9124                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9125                 .channel_mode = alc889_8ch_intel_modes,
9126                 .capsrc_nids = alc889_capsrc_nids,
9127                 .input_mux = &alc889_capture_source,
9128                 .setup = alc889_automute_setup,
9129                 .init_hook = alc_automute_amp,
9130                 .unsol_event = alc_automute_amp_unsol_event,
9131                 .need_dac_fix = 1,
9132         },
9133         [ALC889_INTEL] = {
9134                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9135                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9136                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9137                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9138                 .dac_nids = alc883_dac_nids,
9139                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9140                 .adc_nids = alc889_adc_nids,
9141                 .dig_out_nid = ALC883_DIGOUT_NID,
9142                 .dig_in_nid = ALC883_DIGIN_NID,
9143                 .slave_dig_outs = alc883_slave_dig_outs,
9144                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9145                 .channel_mode = alc889_8ch_intel_modes,
9146                 .capsrc_nids = alc889_capsrc_nids,
9147                 .input_mux = &alc889_capture_source,
9148                 .setup = alc889_automute_setup,
9149                 .init_hook = alc889_intel_init_hook,
9150                 .unsol_event = alc_automute_amp_unsol_event,
9151                 .need_dac_fix = 1,
9152         },
9153         [ALC883_6ST_DIG] = {
9154                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9155                 .init_verbs = { alc883_init_verbs },
9156                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9157                 .dac_nids = alc883_dac_nids,
9158                 .dig_out_nid = ALC883_DIGOUT_NID,
9159                 .dig_in_nid = ALC883_DIGIN_NID,
9160                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9161                 .channel_mode = alc883_sixstack_modes,
9162                 .input_mux = &alc883_capture_source,
9163         },
9164         [ALC883_TARGA_DIG] = {
9165                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9166                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9167                                 alc883_targa_verbs},
9168                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9169                 .dac_nids = alc883_dac_nids,
9170                 .dig_out_nid = ALC883_DIGOUT_NID,
9171                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9172                 .channel_mode = alc883_3ST_6ch_modes,
9173                 .need_dac_fix = 1,
9174                 .input_mux = &alc883_capture_source,
9175                 .unsol_event = alc883_targa_unsol_event,
9176                 .setup = alc882_targa_setup,
9177                 .init_hook = alc882_targa_automute,
9178         },
9179         [ALC883_TARGA_2ch_DIG] = {
9180                 .mixers = { alc883_targa_2ch_mixer},
9181                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9182                                 alc883_targa_verbs},
9183                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9184                 .dac_nids = alc883_dac_nids,
9185                 .adc_nids = alc883_adc_nids_alt,
9186                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9187                 .dig_out_nid = ALC883_DIGOUT_NID,
9188                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9189                 .channel_mode = alc883_3ST_2ch_modes,
9190                 .input_mux = &alc883_capture_source,
9191                 .unsol_event = alc883_targa_unsol_event,
9192                 .setup = alc882_targa_setup,
9193                 .init_hook = alc882_targa_automute,
9194         },
9195         [ALC883_TARGA_8ch_DIG] = {
9196                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9197                             alc883_chmode_mixer },
9198                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9199                                 alc883_targa_verbs },
9200                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9201                 .dac_nids = alc883_dac_nids,
9202                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9203                 .adc_nids = alc883_adc_nids_rev,
9204                 .capsrc_nids = alc883_capsrc_nids_rev,
9205                 .dig_out_nid = ALC883_DIGOUT_NID,
9206                 .dig_in_nid = ALC883_DIGIN_NID,
9207                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9208                 .channel_mode = alc883_4ST_8ch_modes,
9209                 .need_dac_fix = 1,
9210                 .input_mux = &alc883_capture_source,
9211                 .unsol_event = alc883_targa_unsol_event,
9212                 .setup = alc882_targa_setup,
9213                 .init_hook = alc882_targa_automute,
9214         },
9215         [ALC883_ACER] = {
9216                 .mixers = { alc883_base_mixer },
9217                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9218                  * and the headphone jack.  Turn this on and rely on the
9219                  * standard mute methods whenever the user wants to turn
9220                  * these outputs off.
9221                  */
9222                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9223                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9224                 .dac_nids = alc883_dac_nids,
9225                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9226                 .channel_mode = alc883_3ST_2ch_modes,
9227                 .input_mux = &alc883_capture_source,
9228         },
9229         [ALC883_ACER_ASPIRE] = {
9230                 .mixers = { alc883_acer_aspire_mixer },
9231                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9232                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9233                 .dac_nids = alc883_dac_nids,
9234                 .dig_out_nid = ALC883_DIGOUT_NID,
9235                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9236                 .channel_mode = alc883_3ST_2ch_modes,
9237                 .input_mux = &alc883_capture_source,
9238                 .unsol_event = alc_automute_amp_unsol_event,
9239                 .setup = alc883_acer_aspire_setup,
9240                 .init_hook = alc_automute_amp,
9241         },
9242         [ALC888_ACER_ASPIRE_4930G] = {
9243                 .mixers = { alc888_base_mixer,
9244                                 alc883_chmode_mixer },
9245                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9246                                 alc888_acer_aspire_4930g_verbs },
9247                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9248                 .dac_nids = alc883_dac_nids,
9249                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9250                 .adc_nids = alc883_adc_nids_rev,
9251                 .capsrc_nids = alc883_capsrc_nids_rev,
9252                 .dig_out_nid = ALC883_DIGOUT_NID,
9253                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9254                 .channel_mode = alc883_3ST_6ch_modes,
9255                 .need_dac_fix = 1,
9256                 .num_mux_defs =
9257                         ARRAY_SIZE(alc888_2_capture_sources),
9258                 .input_mux = alc888_2_capture_sources,
9259                 .unsol_event = alc_automute_amp_unsol_event,
9260                 .setup = alc888_acer_aspire_4930g_setup,
9261                 .init_hook = alc_automute_amp,
9262         },
9263         [ALC888_ACER_ASPIRE_6530G] = {
9264                 .mixers = { alc888_acer_aspire_6530_mixer },
9265                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9266                                 alc888_acer_aspire_6530g_verbs },
9267                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9268                 .dac_nids = alc883_dac_nids,
9269                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9270                 .adc_nids = alc883_adc_nids_rev,
9271                 .capsrc_nids = alc883_capsrc_nids_rev,
9272                 .dig_out_nid = ALC883_DIGOUT_NID,
9273                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9274                 .channel_mode = alc883_3ST_2ch_modes,
9275                 .num_mux_defs =
9276                         ARRAY_SIZE(alc888_2_capture_sources),
9277                 .input_mux = alc888_acer_aspire_6530_sources,
9278                 .unsol_event = alc_automute_amp_unsol_event,
9279                 .setup = alc888_acer_aspire_6530g_setup,
9280                 .init_hook = alc_automute_amp,
9281         },
9282         [ALC888_ACER_ASPIRE_8930G] = {
9283                 .mixers = { alc888_base_mixer,
9284                                 alc883_chmode_mixer },
9285                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9286                                 alc889_acer_aspire_8930g_verbs },
9287                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9288                 .dac_nids = alc883_dac_nids,
9289                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9290                 .adc_nids = alc889_adc_nids,
9291                 .capsrc_nids = alc889_capsrc_nids,
9292                 .dig_out_nid = ALC883_DIGOUT_NID,
9293                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9294                 .channel_mode = alc883_3ST_6ch_modes,
9295                 .need_dac_fix = 1,
9296                 .const_channel_count = 6,
9297                 .num_mux_defs =
9298                         ARRAY_SIZE(alc889_capture_sources),
9299                 .input_mux = alc889_capture_sources,
9300                 .unsol_event = alc_automute_amp_unsol_event,
9301                 .setup = alc889_acer_aspire_8930g_setup,
9302                 .init_hook = alc_automute_amp,
9303         },
9304         [ALC888_ACER_ASPIRE_7730G] = {
9305                 .mixers = { alc883_3ST_6ch_mixer,
9306                                 alc883_chmode_mixer },
9307                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9308                                 alc888_acer_aspire_7730G_verbs },
9309                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9310                 .dac_nids = alc883_dac_nids,
9311                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9312                 .adc_nids = alc883_adc_nids_rev,
9313                 .capsrc_nids = alc883_capsrc_nids_rev,
9314                 .dig_out_nid = ALC883_DIGOUT_NID,
9315                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9316                 .channel_mode = alc883_3ST_6ch_modes,
9317                 .need_dac_fix = 1,
9318                 .const_channel_count = 6,
9319                 .input_mux = &alc883_capture_source,
9320                 .unsol_event = alc_automute_amp_unsol_event,
9321                 .setup = alc888_acer_aspire_6530g_setup,
9322                 .init_hook = alc_automute_amp,
9323         },
9324         [ALC883_MEDION] = {
9325                 .mixers = { alc883_fivestack_mixer,
9326                             alc883_chmode_mixer },
9327                 .init_verbs = { alc883_init_verbs,
9328                                 alc883_medion_eapd_verbs },
9329                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9330                 .dac_nids = alc883_dac_nids,
9331                 .adc_nids = alc883_adc_nids_alt,
9332                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9333                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9334                 .channel_mode = alc883_sixstack_modes,
9335                 .input_mux = &alc883_capture_source,
9336         },
9337         [ALC883_MEDION_MD2] = {
9338                 .mixers = { alc883_medion_md2_mixer},
9339                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9340                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9341                 .dac_nids = alc883_dac_nids,
9342                 .dig_out_nid = ALC883_DIGOUT_NID,
9343                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9344                 .channel_mode = alc883_3ST_2ch_modes,
9345                 .input_mux = &alc883_capture_source,
9346                 .unsol_event = alc_automute_amp_unsol_event,
9347                 .setup = alc883_medion_md2_setup,
9348                 .init_hook = alc_automute_amp,
9349         },
9350         [ALC883_LAPTOP_EAPD] = {
9351                 .mixers = { alc883_base_mixer },
9352                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9353                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9354                 .dac_nids = alc883_dac_nids,
9355                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9356                 .channel_mode = alc883_3ST_2ch_modes,
9357                 .input_mux = &alc883_capture_source,
9358         },
9359         [ALC883_CLEVO_M540R] = {
9360                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9361                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9362                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9363                 .dac_nids = alc883_dac_nids,
9364                 .dig_out_nid = ALC883_DIGOUT_NID,
9365                 .dig_in_nid = ALC883_DIGIN_NID,
9366                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9367                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9368                 .need_dac_fix = 1,
9369                 .input_mux = &alc883_capture_source,
9370                 /* This machine has the hardware HP auto-muting, thus
9371                  * we need no software mute via unsol event
9372                  */
9373         },
9374         [ALC883_CLEVO_M720] = {
9375                 .mixers = { alc883_clevo_m720_mixer },
9376                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9377                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9378                 .dac_nids = alc883_dac_nids,
9379                 .dig_out_nid = ALC883_DIGOUT_NID,
9380                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9381                 .channel_mode = alc883_3ST_2ch_modes,
9382                 .input_mux = &alc883_capture_source,
9383                 .unsol_event = alc883_clevo_m720_unsol_event,
9384                 .setup = alc883_clevo_m720_setup,
9385                 .init_hook = alc883_clevo_m720_init_hook,
9386         },
9387         [ALC883_LENOVO_101E_2ch] = {
9388                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9389                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9390                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9391                 .dac_nids = alc883_dac_nids,
9392                 .adc_nids = alc883_adc_nids_alt,
9393                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9394                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9395                 .channel_mode = alc883_3ST_2ch_modes,
9396                 .input_mux = &alc883_lenovo_101e_capture_source,
9397                 .unsol_event = alc883_lenovo_101e_unsol_event,
9398                 .init_hook = alc883_lenovo_101e_all_automute,
9399         },
9400         [ALC883_LENOVO_NB0763] = {
9401                 .mixers = { alc883_lenovo_nb0763_mixer },
9402                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9403                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9404                 .dac_nids = alc883_dac_nids,
9405                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9406                 .channel_mode = alc883_3ST_2ch_modes,
9407                 .need_dac_fix = 1,
9408                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9409                 .unsol_event = alc_automute_amp_unsol_event,
9410                 .setup = alc883_medion_md2_setup,
9411                 .init_hook = alc_automute_amp,
9412         },
9413         [ALC888_LENOVO_MS7195_DIG] = {
9414                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9415                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9416                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9417                 .dac_nids = alc883_dac_nids,
9418                 .dig_out_nid = ALC883_DIGOUT_NID,
9419                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9420                 .channel_mode = alc883_3ST_6ch_modes,
9421                 .need_dac_fix = 1,
9422                 .input_mux = &alc883_capture_source,
9423                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9424                 .init_hook = alc888_lenovo_ms7195_front_automute,
9425         },
9426         [ALC883_HAIER_W66] = {
9427                 .mixers = { alc883_targa_2ch_mixer},
9428                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9429                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9430                 .dac_nids = alc883_dac_nids,
9431                 .dig_out_nid = ALC883_DIGOUT_NID,
9432                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9433                 .channel_mode = alc883_3ST_2ch_modes,
9434                 .input_mux = &alc883_capture_source,
9435                 .unsol_event = alc_automute_amp_unsol_event,
9436                 .setup = alc883_haier_w66_setup,
9437                 .init_hook = alc_automute_amp,
9438         },
9439         [ALC888_3ST_HP] = {
9440                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9441                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9442                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9443                 .dac_nids = alc883_dac_nids,
9444                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9445                 .channel_mode = alc888_3st_hp_modes,
9446                 .need_dac_fix = 1,
9447                 .input_mux = &alc883_capture_source,
9448                 .unsol_event = alc_automute_amp_unsol_event,
9449                 .setup = alc888_3st_hp_setup,
9450                 .init_hook = alc_automute_amp,
9451         },
9452         [ALC888_6ST_DELL] = {
9453                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9454                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9455                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9456                 .dac_nids = alc883_dac_nids,
9457                 .dig_out_nid = ALC883_DIGOUT_NID,
9458                 .dig_in_nid = ALC883_DIGIN_NID,
9459                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9460                 .channel_mode = alc883_sixstack_modes,
9461                 .input_mux = &alc883_capture_source,
9462                 .unsol_event = alc_automute_amp_unsol_event,
9463                 .setup = alc888_6st_dell_setup,
9464                 .init_hook = alc_automute_amp,
9465         },
9466         [ALC883_MITAC] = {
9467                 .mixers = { alc883_mitac_mixer },
9468                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9469                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9470                 .dac_nids = alc883_dac_nids,
9471                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9472                 .channel_mode = alc883_3ST_2ch_modes,
9473                 .input_mux = &alc883_capture_source,
9474                 .unsol_event = alc_automute_amp_unsol_event,
9475                 .setup = alc883_mitac_setup,
9476                 .init_hook = alc_automute_amp,
9477         },
9478         [ALC883_FUJITSU_PI2515] = {
9479                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
9480                 .init_verbs = { alc883_init_verbs,
9481                                 alc883_2ch_fujitsu_pi2515_verbs},
9482                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9483                 .dac_nids = alc883_dac_nids,
9484                 .dig_out_nid = ALC883_DIGOUT_NID,
9485                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9486                 .channel_mode = alc883_3ST_2ch_modes,
9487                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9488                 .unsol_event = alc_automute_amp_unsol_event,
9489                 .setup = alc883_2ch_fujitsu_pi2515_setup,
9490                 .init_hook = alc_automute_amp,
9491         },
9492         [ALC888_FUJITSU_XA3530] = {
9493                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
9494                 .init_verbs = { alc883_init_verbs,
9495                         alc888_fujitsu_xa3530_verbs },
9496                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9497                 .dac_nids = alc883_dac_nids,
9498                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9499                 .adc_nids = alc883_adc_nids_rev,
9500                 .capsrc_nids = alc883_capsrc_nids_rev,
9501                 .dig_out_nid = ALC883_DIGOUT_NID,
9502                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
9503                 .channel_mode = alc888_4ST_8ch_intel_modes,
9504                 .num_mux_defs =
9505                         ARRAY_SIZE(alc888_2_capture_sources),
9506                 .input_mux = alc888_2_capture_sources,
9507                 .unsol_event = alc_automute_amp_unsol_event,
9508                 .setup = alc888_fujitsu_xa3530_setup,
9509                 .init_hook = alc_automute_amp,
9510         },
9511         [ALC888_LENOVO_SKY] = {
9512                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
9513                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
9514                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9515                 .dac_nids = alc883_dac_nids,
9516                 .dig_out_nid = ALC883_DIGOUT_NID,
9517                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9518                 .channel_mode = alc883_sixstack_modes,
9519                 .need_dac_fix = 1,
9520                 .input_mux = &alc883_lenovo_sky_capture_source,
9521                 .unsol_event = alc_automute_amp_unsol_event,
9522                 .setup = alc888_lenovo_sky_setup,
9523                 .init_hook = alc_automute_amp,
9524         },
9525         [ALC888_ASUS_M90V] = {
9526                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9527                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
9528                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9529                 .dac_nids = alc883_dac_nids,
9530                 .dig_out_nid = ALC883_DIGOUT_NID,
9531                 .dig_in_nid = ALC883_DIGIN_NID,
9532                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9533                 .channel_mode = alc883_3ST_6ch_modes,
9534                 .need_dac_fix = 1,
9535                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
9536                 .unsol_event = alc_sku_unsol_event,
9537                 .setup = alc883_mode2_setup,
9538                 .init_hook = alc_inithook,
9539         },
9540         [ALC888_ASUS_EEE1601] = {
9541                 .mixers = { alc883_asus_eee1601_mixer },
9542                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
9543                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
9544                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9545                 .dac_nids = alc883_dac_nids,
9546                 .dig_out_nid = ALC883_DIGOUT_NID,
9547                 .dig_in_nid = ALC883_DIGIN_NID,
9548                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9549                 .channel_mode = alc883_3ST_2ch_modes,
9550                 .need_dac_fix = 1,
9551                 .input_mux = &alc883_asus_eee1601_capture_source,
9552                 .unsol_event = alc_sku_unsol_event,
9553                 .init_hook = alc883_eee1601_inithook,
9554         },
9555         [ALC1200_ASUS_P5Q] = {
9556                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9557                 .init_verbs = { alc883_init_verbs },
9558                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9559                 .dac_nids = alc883_dac_nids,
9560                 .dig_out_nid = ALC1200_DIGOUT_NID,
9561                 .dig_in_nid = ALC883_DIGIN_NID,
9562                 .slave_dig_outs = alc1200_slave_dig_outs,
9563                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9564                 .channel_mode = alc883_sixstack_modes,
9565                 .input_mux = &alc883_capture_source,
9566         },
9567         [ALC889A_MB31] = {
9568                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
9569                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
9570                         alc880_gpio1_init_verbs },
9571                 .adc_nids = alc883_adc_nids,
9572                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9573                 .dac_nids = alc883_dac_nids,
9574                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9575                 .channel_mode = alc889A_mb31_6ch_modes,
9576                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
9577                 .input_mux = &alc889A_mb31_capture_source,
9578                 .dig_out_nid = ALC883_DIGOUT_NID,
9579                 .unsol_event = alc889A_mb31_unsol_event,
9580                 .init_hook = alc889A_mb31_automute,
9581         },
9582         [ALC883_SONY_VAIO_TT] = {
9583                 .mixers = { alc883_vaiott_mixer },
9584                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
9585                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9586                 .dac_nids = alc883_dac_nids,
9587                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9588                 .channel_mode = alc883_3ST_2ch_modes,
9589                 .input_mux = &alc883_capture_source,
9590                 .unsol_event = alc_automute_amp_unsol_event,
9591                 .setup = alc883_vaiott_setup,
9592                 .init_hook = alc_automute_amp,
9593         },
9594 };
9595
9596
9597 /*
9598  * Pin config fixes
9599  */
9600 enum {
9601         PINFIX_ABIT_AW9D_MAX
9602 };
9603
9604 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
9605         { 0x15, 0x01080104 }, /* side */
9606         { 0x16, 0x01011012 }, /* rear */
9607         { 0x17, 0x01016011 }, /* clfe */
9608         { }
9609 };
9610
9611 static const struct alc_fixup alc882_fixups[] = {
9612         [PINFIX_ABIT_AW9D_MAX] = {
9613                 .pins = alc882_abit_aw9d_pinfix
9614         },
9615 };
9616
9617 static struct snd_pci_quirk alc882_fixup_tbl[] = {
9618         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
9619         {}
9620 };
9621
9622 /*
9623  * BIOS auto configuration
9624  */
9625 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
9626                                                 const struct auto_pin_cfg *cfg)
9627 {
9628         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
9629 }
9630
9631 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
9632                                               hda_nid_t nid, int pin_type,
9633                                               int dac_idx)
9634 {
9635         /* set as output */
9636         struct alc_spec *spec = codec->spec;
9637         int idx;
9638
9639         alc_set_pin_output(codec, nid, pin_type);
9640         if (spec->multiout.dac_nids[dac_idx] == 0x25)
9641                 idx = 4;
9642         else
9643                 idx = spec->multiout.dac_nids[dac_idx] - 2;
9644         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
9645
9646 }
9647
9648 static void alc882_auto_init_multi_out(struct hda_codec *codec)
9649 {
9650         struct alc_spec *spec = codec->spec;
9651         int i;
9652
9653         for (i = 0; i <= HDA_SIDE; i++) {
9654                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
9655                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
9656                 if (nid)
9657                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
9658                                                           i);
9659         }
9660 }
9661
9662 static void alc882_auto_init_hp_out(struct hda_codec *codec)
9663 {
9664         struct alc_spec *spec = codec->spec;
9665         hda_nid_t pin;
9666
9667         pin = spec->autocfg.hp_pins[0];
9668         if (pin) /* connect to front */
9669                 /* use dac 0 */
9670                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
9671         pin = spec->autocfg.speaker_pins[0];
9672         if (pin)
9673                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
9674 }
9675
9676 static void alc882_auto_init_analog_input(struct hda_codec *codec)
9677 {
9678         struct alc_spec *spec = codec->spec;
9679         int i;
9680
9681         for (i = 0; i < AUTO_PIN_LAST; i++) {
9682                 hda_nid_t nid = spec->autocfg.input_pins[i];
9683                 if (!nid)
9684                         continue;
9685                 alc_set_input_pin(codec, nid, i);
9686                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
9687                         snd_hda_codec_write(codec, nid, 0,
9688                                             AC_VERB_SET_AMP_GAIN_MUTE,
9689                                             AMP_OUT_MUTE);
9690         }
9691 }
9692
9693 static void alc882_auto_init_input_src(struct hda_codec *codec)
9694 {
9695         struct alc_spec *spec = codec->spec;
9696         int c;
9697
9698         for (c = 0; c < spec->num_adc_nids; c++) {
9699                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
9700                 hda_nid_t nid = spec->capsrc_nids[c];
9701                 unsigned int mux_idx;
9702                 const struct hda_input_mux *imux;
9703                 int conns, mute, idx, item;
9704
9705                 conns = snd_hda_get_connections(codec, nid, conn_list,
9706                                                 ARRAY_SIZE(conn_list));
9707                 if (conns < 0)
9708                         continue;
9709                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
9710                 imux = &spec->input_mux[mux_idx];
9711                 for (idx = 0; idx < conns; idx++) {
9712                         /* if the current connection is the selected one,
9713                          * unmute it as default - otherwise mute it
9714                          */
9715                         mute = AMP_IN_MUTE(idx);
9716                         for (item = 0; item < imux->num_items; item++) {
9717                                 if (imux->items[item].index == idx) {
9718                                         if (spec->cur_mux[c] == item)
9719                                                 mute = AMP_IN_UNMUTE(idx);
9720                                         break;
9721                                 }
9722                         }
9723                         /* check if we have a selector or mixer
9724                          * we could check for the widget type instead, but
9725                          * just check for Amp-In presence (in case of mixer
9726                          * without amp-in there is something wrong, this
9727                          * function shouldn't be used or capsrc nid is wrong)
9728                          */
9729                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
9730                                 snd_hda_codec_write(codec, nid, 0,
9731                                                     AC_VERB_SET_AMP_GAIN_MUTE,
9732                                                     mute);
9733                         else if (mute != AMP_IN_MUTE(idx))
9734                                 snd_hda_codec_write(codec, nid, 0,
9735                                                     AC_VERB_SET_CONNECT_SEL,
9736                                                     idx);
9737                 }
9738         }
9739 }
9740
9741 /* add mic boosts if needed */
9742 static int alc_auto_add_mic_boost(struct hda_codec *codec)
9743 {
9744         struct alc_spec *spec = codec->spec;
9745         int err;
9746         hda_nid_t nid;
9747
9748         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
9749         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9750                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9751                                   "Mic Boost",
9752                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9753                 if (err < 0)
9754                         return err;
9755         }
9756         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
9757         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
9758                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
9759                                   "Front Mic Boost",
9760                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
9761                 if (err < 0)
9762                         return err;
9763         }
9764         return 0;
9765 }
9766
9767 /* almost identical with ALC880 parser... */
9768 static int alc882_parse_auto_config(struct hda_codec *codec)
9769 {
9770         struct alc_spec *spec = codec->spec;
9771         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
9772         int i, err;
9773
9774         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
9775                                            alc882_ignore);
9776         if (err < 0)
9777                 return err;
9778         if (!spec->autocfg.line_outs)
9779                 return 0; /* can't find valid BIOS pin config */
9780
9781         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
9782         if (err < 0)
9783                 return err;
9784         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
9785         if (err < 0)
9786                 return err;
9787         err = alc880_auto_create_extra_out(spec,
9788                                            spec->autocfg.speaker_pins[0],
9789                                            "Speaker");
9790         if (err < 0)
9791                 return err;
9792         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
9793                                            "Headphone");
9794         if (err < 0)
9795                 return err;
9796         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
9797         if (err < 0)
9798                 return err;
9799
9800         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
9801
9802         /* check multiple SPDIF-out (for recent codecs) */
9803         for (i = 0; i < spec->autocfg.dig_outs; i++) {
9804                 hda_nid_t dig_nid;
9805                 err = snd_hda_get_connections(codec,
9806                                               spec->autocfg.dig_out_pins[i],
9807                                               &dig_nid, 1);
9808                 if (err < 0)
9809                         continue;
9810                 if (!i)
9811                         spec->multiout.dig_out_nid = dig_nid;
9812                 else {
9813                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
9814                         spec->slave_dig_outs[i - 1] = dig_nid;
9815                         if (i == ARRAY_SIZE(spec->slave_dig_outs) - 1)
9816                                 break;
9817                 }
9818         }
9819         if (spec->autocfg.dig_in_pin)
9820                 spec->dig_in_nid = ALC880_DIGIN_NID;
9821
9822         if (spec->kctls.list)
9823                 add_mixer(spec, spec->kctls.list);
9824
9825         add_verb(spec, alc883_auto_init_verbs);
9826         /* if ADC 0x07 is available, initialize it, too */
9827         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
9828                 add_verb(spec, alc882_adc1_init_verbs);
9829
9830         spec->num_mux_defs = 1;
9831         spec->input_mux = &spec->private_imux[0];
9832
9833         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
9834
9835         err = alc_auto_add_mic_boost(codec);
9836         if (err < 0)
9837                 return err;
9838
9839         return 1; /* config found */
9840 }
9841
9842 /* additional initialization for auto-configuration model */
9843 static void alc882_auto_init(struct hda_codec *codec)
9844 {
9845         struct alc_spec *spec = codec->spec;
9846         alc882_auto_init_multi_out(codec);
9847         alc882_auto_init_hp_out(codec);
9848         alc882_auto_init_analog_input(codec);
9849         alc882_auto_init_input_src(codec);
9850         if (spec->unsol_event)
9851                 alc_inithook(codec);
9852 }
9853
9854 static int patch_alc882(struct hda_codec *codec)
9855 {
9856         struct alc_spec *spec;
9857         int err, board_config;
9858
9859         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
9860         if (spec == NULL)
9861                 return -ENOMEM;
9862
9863         codec->spec = spec;
9864
9865         switch (codec->vendor_id) {
9866         case 0x10ec0882:
9867         case 0x10ec0885:
9868                 break;
9869         default:
9870                 /* ALC883 and variants */
9871                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
9872                 break;
9873         }
9874
9875         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
9876                                                   alc882_models,
9877                                                   alc882_cfg_tbl);
9878
9879         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
9880                 board_config = snd_hda_check_board_codec_sid_config(codec,
9881                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
9882
9883         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
9884                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
9885                        codec->chip_name);
9886                 board_config = ALC882_AUTO;
9887         }
9888
9889         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
9890
9891         if (board_config == ALC882_AUTO) {
9892                 /* automatic parse from the BIOS config */
9893                 err = alc882_parse_auto_config(codec);
9894                 if (err < 0) {
9895                         alc_free(codec);
9896                         return err;
9897                 } else if (!err) {
9898                         printk(KERN_INFO
9899                                "hda_codec: Cannot set up configuration "
9900                                "from BIOS.  Using base mode...\n");
9901                         board_config = ALC882_3ST_DIG;
9902                 }
9903         }
9904
9905         err = snd_hda_attach_beep_device(codec, 0x1);
9906         if (err < 0) {
9907                 alc_free(codec);
9908                 return err;
9909         }
9910
9911         if (board_config != ALC882_AUTO)
9912                 setup_preset(codec, &alc882_presets[board_config]);
9913
9914         spec->stream_analog_playback = &alc882_pcm_analog_playback;
9915         spec->stream_analog_capture = &alc882_pcm_analog_capture;
9916         /* FIXME: setup DAC5 */
9917         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
9918         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
9919
9920         spec->stream_digital_playback = &alc882_pcm_digital_playback;
9921         spec->stream_digital_capture = &alc882_pcm_digital_capture;
9922
9923         if (codec->vendor_id == 0x10ec0888)
9924                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
9925
9926         if (!spec->adc_nids && spec->input_mux) {
9927                 int i;
9928                 spec->num_adc_nids = 0;
9929                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
9930                         hda_nid_t cap;
9931                         hda_nid_t nid = alc882_adc_nids[i];
9932                         unsigned int wcap = get_wcaps(codec, nid);
9933                         /* get type */
9934                         wcap = get_wcaps_type(wcap);
9935                         if (wcap != AC_WID_AUD_IN)
9936                                 continue;
9937                         spec->private_adc_nids[spec->num_adc_nids] = nid;
9938                         err = snd_hda_get_connections(codec, nid, &cap, 1);
9939                         if (err < 0)
9940                                 continue;
9941                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
9942                         spec->num_adc_nids++;
9943                 }
9944                 spec->adc_nids = spec->private_adc_nids;
9945                 spec->capsrc_nids = spec->private_capsrc_nids;
9946         }
9947
9948         set_capture_mixer(codec);
9949         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
9950
9951         spec->vmaster_nid = 0x0c;
9952
9953         codec->patch_ops = alc_patch_ops;
9954         if (board_config == ALC882_AUTO)
9955                 spec->init_hook = alc882_auto_init;
9956 #ifdef CONFIG_SND_HDA_POWER_SAVE
9957         if (!spec->loopback.amplist)
9958                 spec->loopback.amplist = alc882_loopbacks;
9959 #endif
9960         codec->proc_widget_hook = print_realtek_coef;
9961
9962         return 0;
9963 }
9964
9965
9966 /*
9967  * ALC262 support
9968  */
9969
9970 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
9971 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
9972
9973 #define alc262_dac_nids         alc260_dac_nids
9974 #define alc262_adc_nids         alc882_adc_nids
9975 #define alc262_adc_nids_alt     alc882_adc_nids_alt
9976 #define alc262_capsrc_nids      alc882_capsrc_nids
9977 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
9978
9979 #define alc262_modes            alc260_modes
9980 #define alc262_capture_source   alc882_capture_source
9981
9982 static hda_nid_t alc262_dmic_adc_nids[1] = {
9983         /* ADC0 */
9984         0x09
9985 };
9986
9987 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
9988
9989 static struct snd_kcontrol_new alc262_base_mixer[] = {
9990         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
9991         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
9992         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
9993         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
9994         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
9995         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
9996         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
9997         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
9998         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
9999         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10000         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10001         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10002         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10003         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10004         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10005         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10006         { } /* end */
10007 };
10008
10009 /* update HP, line and mono-out pins according to the master switch */
10010 static void alc262_hp_master_update(struct hda_codec *codec)
10011 {
10012         struct alc_spec *spec = codec->spec;
10013         int val = spec->master_sw;
10014
10015         /* HP & line-out */
10016         snd_hda_codec_write_cache(codec, 0x1b, 0,
10017                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10018                                   val ? PIN_HP : 0);
10019         snd_hda_codec_write_cache(codec, 0x15, 0,
10020                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10021                                   val ? PIN_HP : 0);
10022         /* mono (speaker) depending on the HP jack sense */
10023         val = val && !spec->jack_present;
10024         snd_hda_codec_write_cache(codec, 0x16, 0,
10025                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10026                                   val ? PIN_OUT : 0);
10027 }
10028
10029 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10030 {
10031         struct alc_spec *spec = codec->spec;
10032         unsigned int presence;
10033         presence = snd_hda_codec_read(codec, 0x1b, 0,
10034                                       AC_VERB_GET_PIN_SENSE, 0);
10035         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
10036         alc262_hp_master_update(codec);
10037 }
10038
10039 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10040 {
10041         if ((res >> 26) != ALC880_HP_EVENT)
10042                 return;
10043         alc262_hp_bpc_automute(codec);
10044 }
10045
10046 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10047 {
10048         struct alc_spec *spec = codec->spec;
10049         unsigned int presence;
10050         presence = snd_hda_codec_read(codec, 0x15, 0,
10051                                       AC_VERB_GET_PIN_SENSE, 0);
10052         spec->jack_present = !!(presence & AC_PINSENSE_PRESENCE);
10053         alc262_hp_master_update(codec);
10054 }
10055
10056 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10057                                            unsigned int res)
10058 {
10059         if ((res >> 26) != ALC880_HP_EVENT)
10060                 return;
10061         alc262_hp_wildwest_automute(codec);
10062 }
10063
10064 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10065
10066 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10067                                    struct snd_ctl_elem_value *ucontrol)
10068 {
10069         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10070         struct alc_spec *spec = codec->spec;
10071         int val = !!*ucontrol->value.integer.value;
10072
10073         if (val == spec->master_sw)
10074                 return 0;
10075         spec->master_sw = val;
10076         alc262_hp_master_update(codec);
10077         return 1;
10078 }
10079
10080 #define ALC262_HP_MASTER_SWITCH                                 \
10081         {                                                       \
10082                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10083                 .name = "Master Playback Switch",               \
10084                 .info = snd_ctl_boolean_mono_info,              \
10085                 .get = alc262_hp_master_sw_get,                 \
10086                 .put = alc262_hp_master_sw_put,                 \
10087         }
10088
10089 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10090         ALC262_HP_MASTER_SWITCH,
10091         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10092         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10093         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10094         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10095                               HDA_OUTPUT),
10096         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10097                             HDA_OUTPUT),
10098         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10099         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10100         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10101         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10102         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10103         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10104         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10105         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10106         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10107         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10108         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10109         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10110         { } /* end */
10111 };
10112
10113 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10114         ALC262_HP_MASTER_SWITCH,
10115         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10116         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10117         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10118         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10119         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10120                               HDA_OUTPUT),
10121         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10122                             HDA_OUTPUT),
10123         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10124         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10125         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10126         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10127         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10128         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10129         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10130         { } /* end */
10131 };
10132
10133 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10134         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10135         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10136         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10137         { } /* end */
10138 };
10139
10140 /* mute/unmute internal speaker according to the hp jack and mute state */
10141 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10142 {
10143         struct alc_spec *spec = codec->spec;
10144
10145         spec->autocfg.hp_pins[0] = 0x15;
10146         spec->autocfg.speaker_pins[0] = 0x0c; /* HACK: not actually a pin */
10147 }
10148
10149 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10150         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10151         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10152         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10153         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10154         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10155         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10156         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10157         { } /* end */
10158 };
10159
10160 static struct hda_verb alc262_hp_t5735_verbs[] = {
10161         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10162         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10163
10164         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10165         { }
10166 };
10167
10168 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10169         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10170         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10171         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10172         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10173         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10174         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10175         { } /* end */
10176 };
10177
10178 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10179         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10180         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10181         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10182         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10183         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10184         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10185         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10186         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10187         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10188         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10189         {}
10190 };
10191
10192 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10193         .num_items = 1,
10194         .items = {
10195                 { "Line", 0x1 },
10196         },
10197 };
10198
10199 /* bind hp and internal speaker mute (with plug check) as master switch */
10200 static void alc262_hippo_master_update(struct hda_codec *codec)
10201 {
10202         struct alc_spec *spec = codec->spec;
10203         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10204         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10205         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10206         unsigned int mute;
10207
10208         /* HP */
10209         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10210         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10211                                  HDA_AMP_MUTE, mute);
10212         /* mute internal speaker per jack sense */
10213         if (spec->jack_present)
10214                 mute = HDA_AMP_MUTE;
10215         if (line_nid)
10216                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10217                                          HDA_AMP_MUTE, mute);
10218         if (speaker_nid && speaker_nid != line_nid)
10219                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10220                                          HDA_AMP_MUTE, mute);
10221 }
10222
10223 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10224
10225 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10226                                       struct snd_ctl_elem_value *ucontrol)
10227 {
10228         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10229         struct alc_spec *spec = codec->spec;
10230         int val = !!*ucontrol->value.integer.value;
10231
10232         if (val == spec->master_sw)
10233                 return 0;
10234         spec->master_sw = val;
10235         alc262_hippo_master_update(codec);
10236         return 1;
10237 }
10238
10239 #define ALC262_HIPPO_MASTER_SWITCH                              \
10240         {                                                       \
10241                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10242                 .name = "Master Playback Switch",               \
10243                 .info = snd_ctl_boolean_mono_info,              \
10244                 .get = alc262_hippo_master_sw_get,              \
10245                 .put = alc262_hippo_master_sw_put,              \
10246         }
10247
10248 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10249         ALC262_HIPPO_MASTER_SWITCH,
10250         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10251         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10252         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10253         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10254         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10255         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10256         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10257         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10258         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10259         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10260         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10261         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10262         { } /* end */
10263 };
10264
10265 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10266         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10267         ALC262_HIPPO_MASTER_SWITCH,
10268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10270         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10271         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10273         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10274         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10275         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10276         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10277         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10278         { } /* end */
10279 };
10280
10281 /* mute/unmute internal speaker according to the hp jack and mute state */
10282 static void alc262_hippo_automute(struct hda_codec *codec)
10283 {
10284         struct alc_spec *spec = codec->spec;
10285         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10286         unsigned int present;
10287
10288         /* need to execute and sync at first */
10289         snd_hda_codec_read(codec, hp_nid, 0, AC_VERB_SET_PIN_SENSE, 0);
10290         present = snd_hda_codec_read(codec, hp_nid, 0,
10291                                      AC_VERB_GET_PIN_SENSE, 0);
10292         spec->jack_present = (present & 0x80000000) != 0;
10293         alc262_hippo_master_update(codec);
10294 }
10295
10296 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10297 {
10298         if ((res >> 26) != ALC880_HP_EVENT)
10299                 return;
10300         alc262_hippo_automute(codec);
10301 }
10302
10303 static void alc262_hippo_setup(struct hda_codec *codec)
10304 {
10305         struct alc_spec *spec = codec->spec;
10306
10307         spec->autocfg.hp_pins[0] = 0x15;
10308         spec->autocfg.speaker_pins[0] = 0x14;
10309 }
10310
10311 static void alc262_hippo1_setup(struct hda_codec *codec)
10312 {
10313         struct alc_spec *spec = codec->spec;
10314
10315         spec->autocfg.hp_pins[0] = 0x1b;
10316         spec->autocfg.speaker_pins[0] = 0x14;
10317 }
10318
10319
10320 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10321         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10322         ALC262_HIPPO_MASTER_SWITCH,
10323         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10324         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10325         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10326         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10327         { } /* end */
10328 };
10329
10330 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10331         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10332         ALC262_HIPPO_MASTER_SWITCH,
10333         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10334         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10335         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10336         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10337         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10338         { } /* end */
10339 };
10340
10341 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10342         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10343         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10344         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10345         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10346         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10347         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10348         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10349         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10350         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10351         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10352         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10353         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10354         { } /* end */
10355 };
10356
10357 static struct hda_verb alc262_tyan_verbs[] = {
10358         /* Headphone automute */
10359         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10360         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10361         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10362
10363         /* P11 AUX_IN, white 4-pin connector */
10364         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10365         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10366         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10367         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10368
10369         {}
10370 };
10371
10372 /* unsolicited event for HP jack sensing */
10373 static void alc262_tyan_setup(struct hda_codec *codec)
10374 {
10375         struct alc_spec *spec = codec->spec;
10376
10377         spec->autocfg.hp_pins[0] = 0x1b;
10378         spec->autocfg.speaker_pins[0] = 0x15;
10379 }
10380
10381
10382 #define alc262_capture_mixer            alc882_capture_mixer
10383 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10384
10385 /*
10386  * generic initialization of ADC, input mixers and output mixers
10387  */
10388 static struct hda_verb alc262_init_verbs[] = {
10389         /*
10390          * Unmute ADC0-2 and set the default input to mic-in
10391          */
10392         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10393         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10394         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10395         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10396         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10397         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10398
10399         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10400          * mixer widget
10401          * Note: PASD motherboards uses the Line In 2 as the input for
10402          * front panel mic (mic 2)
10403          */
10404         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10405         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10406         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10407         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10408         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10409         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10410
10411         /*
10412          * Set up output mixers (0x0c - 0x0e)
10413          */
10414         /* set vol=0 to output mixers */
10415         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10416         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10417         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10418         /* set up input amps for analog loopback */
10419         /* Amp Indices: DAC = 0, mixer = 1 */
10420         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10421         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10422         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10423         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10424         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10425         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10426
10427         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10428         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10429         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10430         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10431         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10432         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10433
10434         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10435         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10436         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10437         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10438         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10439
10440         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10441         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10442
10443         /* FIXME: use matrix-type input source selection */
10444         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10445         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10446         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10447         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10448         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10449         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10450         /* Input mixer2 */
10451         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10452         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10453         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10454         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10455         /* Input mixer3 */
10456         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10457         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10458         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10459         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10460
10461         { }
10462 };
10463
10464 static struct hda_verb alc262_eapd_verbs[] = {
10465         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
10466         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
10467         { }
10468 };
10469
10470 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
10471         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10472         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10473         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10474
10475         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10476         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10477         {}
10478 };
10479
10480 static struct hda_verb alc262_sony_unsol_verbs[] = {
10481         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10482         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10483         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
10484
10485         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10486         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10487         {}
10488 };
10489
10490 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
10491         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10492         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10493         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10494         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10495         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10496         { } /* end */
10497 };
10498
10499 static struct hda_verb alc262_toshiba_s06_verbs[] = {
10500         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10501         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10502         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10503         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10504         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
10505         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10506         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
10507         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10508         {}
10509 };
10510
10511 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
10512 {
10513         struct alc_spec *spec = codec->spec;
10514
10515         spec->autocfg.hp_pins[0] = 0x15;
10516         spec->autocfg.speaker_pins[0] = 0x14;
10517         spec->ext_mic.pin = 0x18;
10518         spec->ext_mic.mux_idx = 0;
10519         spec->int_mic.pin = 0x12;
10520         spec->int_mic.mux_idx = 9;
10521         spec->auto_mic = 1;
10522 }
10523
10524 /*
10525  * nec model
10526  *  0x15 = headphone
10527  *  0x16 = internal speaker
10528  *  0x18 = external mic
10529  */
10530
10531 static struct snd_kcontrol_new alc262_nec_mixer[] = {
10532         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
10533         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
10534
10535         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10536         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10537         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10538
10539         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10540         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10541         { } /* end */
10542 };
10543
10544 static struct hda_verb alc262_nec_verbs[] = {
10545         /* Unmute Speaker */
10546         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10547
10548         /* Headphone */
10549         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10550         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10551
10552         /* External mic to headphone */
10553         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10554         /* External mic to speaker */
10555         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10556         {}
10557 };
10558
10559 /*
10560  * fujitsu model
10561  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
10562  *  0x1b = port replicator headphone out
10563  */
10564
10565 #define ALC_HP_EVENT    0x37
10566
10567 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
10568         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10569         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10570         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10571         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10572         {}
10573 };
10574
10575 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
10576         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
10577         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10578         {}
10579 };
10580
10581 static struct hda_input_mux alc262_fujitsu_capture_source = {
10582         .num_items = 3,
10583         .items = {
10584                 { "Mic", 0x0 },
10585                 { "Int Mic", 0x1 },
10586                 { "CD", 0x4 },
10587         },
10588 };
10589
10590 static struct hda_input_mux alc262_HP_capture_source = {
10591         .num_items = 5,
10592         .items = {
10593                 { "Mic", 0x0 },
10594                 { "Front Mic", 0x1 },
10595                 { "Line", 0x2 },
10596                 { "CD", 0x4 },
10597                 { "AUX IN", 0x6 },
10598         },
10599 };
10600
10601 static struct hda_input_mux alc262_HP_D7000_capture_source = {
10602         .num_items = 4,
10603         .items = {
10604                 { "Mic", 0x0 },
10605                 { "Front Mic", 0x2 },
10606                 { "Line", 0x1 },
10607                 { "CD", 0x4 },
10608         },
10609 };
10610
10611 /* mute/unmute internal speaker according to the hp jacks and mute state */
10612 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
10613 {
10614         struct alc_spec *spec = codec->spec;
10615         unsigned int mute;
10616
10617         if (force || !spec->sense_updated) {
10618                 unsigned int present;
10619                 /* need to execute and sync at first */
10620                 snd_hda_codec_read(codec, 0x14, 0, AC_VERB_SET_PIN_SENSE, 0);
10621                 /* check laptop HP jack */
10622                 present = snd_hda_codec_read(codec, 0x14, 0,
10623                                              AC_VERB_GET_PIN_SENSE, 0);
10624                 /* need to execute and sync at first */
10625                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10626                 /* check docking HP jack */
10627                 present |= snd_hda_codec_read(codec, 0x1b, 0,
10628                                               AC_VERB_GET_PIN_SENSE, 0);
10629                 if (present & AC_PINSENSE_PRESENCE)
10630                         spec->jack_present = 1;
10631                 else
10632                         spec->jack_present = 0;
10633                 spec->sense_updated = 1;
10634         }
10635         /* unmute internal speaker only if both HPs are unplugged and
10636          * master switch is on
10637          */
10638         if (spec->jack_present)
10639                 mute = HDA_AMP_MUTE;
10640         else
10641                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
10642         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10643                                  HDA_AMP_MUTE, mute);
10644 }
10645
10646 /* unsolicited event for HP jack sensing */
10647 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
10648                                        unsigned int res)
10649 {
10650         if ((res >> 26) != ALC_HP_EVENT)
10651                 return;
10652         alc262_fujitsu_automute(codec, 1);
10653 }
10654
10655 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
10656 {
10657         alc262_fujitsu_automute(codec, 1);
10658 }
10659
10660 /* bind volumes of both NID 0x0c and 0x0d */
10661 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
10662         .ops = &snd_hda_bind_vol,
10663         .values = {
10664                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
10665                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
10666                 0
10667         },
10668 };
10669
10670 /* mute/unmute internal speaker according to the hp jack and mute state */
10671 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
10672 {
10673         struct alc_spec *spec = codec->spec;
10674         unsigned int mute;
10675
10676         if (force || !spec->sense_updated) {
10677                 unsigned int present_int_hp;
10678                 /* need to execute and sync at first */
10679                 snd_hda_codec_read(codec, 0x1b, 0, AC_VERB_SET_PIN_SENSE, 0);
10680                 present_int_hp = snd_hda_codec_read(codec, 0x1b, 0,
10681                                         AC_VERB_GET_PIN_SENSE, 0);
10682                 spec->jack_present = (present_int_hp & 0x80000000) != 0;
10683                 spec->sense_updated = 1;
10684         }
10685         if (spec->jack_present) {
10686                 /* mute internal speaker */
10687                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10688                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10689                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10690                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
10691         } else {
10692                 /* unmute internal speaker if necessary */
10693                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
10694                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10695                                          HDA_AMP_MUTE, mute);
10696                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
10697                                          HDA_AMP_MUTE, mute);
10698         }
10699 }
10700
10701 /* unsolicited event for HP jack sensing */
10702 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
10703                                        unsigned int res)
10704 {
10705         if ((res >> 26) != ALC_HP_EVENT)
10706                 return;
10707         alc262_lenovo_3000_automute(codec, 1);
10708 }
10709
10710 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
10711                                   int dir, int idx, long *valp)
10712 {
10713         int i, change = 0;
10714
10715         for (i = 0; i < 2; i++, valp++)
10716                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
10717                                                    HDA_AMP_MUTE,
10718                                                    *valp ? 0 : HDA_AMP_MUTE);
10719         return change;
10720 }
10721
10722 /* bind hp and internal speaker mute (with plug check) */
10723 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
10724                                          struct snd_ctl_elem_value *ucontrol)
10725 {
10726         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10727         long *valp = ucontrol->value.integer.value;
10728         int change;
10729
10730         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
10731         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10732         if (change)
10733                 alc262_fujitsu_automute(codec, 0);
10734         return change;
10735 }
10736
10737 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
10738         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10739         {
10740                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10741                 .name = "Master Playback Switch",
10742                 .info = snd_hda_mixer_amp_switch_info,
10743                 .get = snd_hda_mixer_amp_switch_get,
10744                 .put = alc262_fujitsu_master_sw_put,
10745                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
10746         },
10747         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10748         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10749         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10750         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10751         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10752         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10753         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10754         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10755         { } /* end */
10756 };
10757
10758 /* bind hp and internal speaker mute (with plug check) */
10759 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
10760                                          struct snd_ctl_elem_value *ucontrol)
10761 {
10762         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10763         long *valp = ucontrol->value.integer.value;
10764         int change;
10765
10766         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
10767         if (change)
10768                 alc262_lenovo_3000_automute(codec, 0);
10769         return change;
10770 }
10771
10772 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
10773         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10774         {
10775                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10776                 .name = "Master Playback Switch",
10777                 .info = snd_hda_mixer_amp_switch_info,
10778                 .get = snd_hda_mixer_amp_switch_get,
10779                 .put = alc262_lenovo_3000_master_sw_put,
10780                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
10781         },
10782         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10783         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10784         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10785         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10786         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10787         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
10788         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
10789         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
10790         { } /* end */
10791 };
10792
10793 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
10794         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
10795         ALC262_HIPPO_MASTER_SWITCH,
10796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10798         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10799         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10800         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10801         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10802         { } /* end */
10803 };
10804
10805 /* additional init verbs for Benq laptops */
10806 static struct hda_verb alc262_EAPD_verbs[] = {
10807         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10808         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
10809         {}
10810 };
10811
10812 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
10813         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10814         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10815
10816         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
10817         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
10818         {}
10819 };
10820
10821 /* Samsung Q1 Ultra Vista model setup */
10822 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
10823         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10824         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10825         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10826         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10827         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
10828         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
10829         { } /* end */
10830 };
10831
10832 static struct hda_verb alc262_ultra_verbs[] = {
10833         /* output mixer */
10834         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10835         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10836         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10837         /* speaker */
10838         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10839         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10840         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10841         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10842         /* HP */
10843         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10844         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
10845         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10846         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10847         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10848         /* internal mic */
10849         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
10850         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10851         /* ADC, choose mic */
10852         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10853         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10854         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10855         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10856         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10857         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10858         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
10859         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
10860         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
10861         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
10862         {}
10863 };
10864
10865 /* mute/unmute internal speaker according to the hp jack and mute state */
10866 static void alc262_ultra_automute(struct hda_codec *codec)
10867 {
10868         struct alc_spec *spec = codec->spec;
10869         unsigned int mute;
10870
10871         mute = 0;
10872         /* auto-mute only when HP is used as HP */
10873         if (!spec->cur_mux[0]) {
10874                 unsigned int present;
10875                 /* need to execute and sync at first */
10876                 snd_hda_codec_read(codec, 0x15, 0, AC_VERB_SET_PIN_SENSE, 0);
10877                 present = snd_hda_codec_read(codec, 0x15, 0,
10878                                              AC_VERB_GET_PIN_SENSE, 0);
10879                 spec->jack_present = (present & AC_PINSENSE_PRESENCE) != 0;
10880                 if (spec->jack_present)
10881                         mute = HDA_AMP_MUTE;
10882         }
10883         /* mute/unmute internal speaker */
10884         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
10885                                  HDA_AMP_MUTE, mute);
10886         /* mute/unmute HP */
10887         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
10888                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
10889 }
10890
10891 /* unsolicited event for HP jack sensing */
10892 static void alc262_ultra_unsol_event(struct hda_codec *codec,
10893                                        unsigned int res)
10894 {
10895         if ((res >> 26) != ALC880_HP_EVENT)
10896                 return;
10897         alc262_ultra_automute(codec);
10898 }
10899
10900 static struct hda_input_mux alc262_ultra_capture_source = {
10901         .num_items = 2,
10902         .items = {
10903                 { "Mic", 0x1 },
10904                 { "Headphone", 0x7 },
10905         },
10906 };
10907
10908 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
10909                                      struct snd_ctl_elem_value *ucontrol)
10910 {
10911         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10912         struct alc_spec *spec = codec->spec;
10913         int ret;
10914
10915         ret = alc_mux_enum_put(kcontrol, ucontrol);
10916         if (!ret)
10917                 return 0;
10918         /* reprogram the HP pin as mic or HP according to the input source */
10919         snd_hda_codec_write_cache(codec, 0x15, 0,
10920                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10921                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
10922         alc262_ultra_automute(codec); /* mute/unmute HP */
10923         return ret;
10924 }
10925
10926 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
10927         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
10928         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
10929         {
10930                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
10931                 .name = "Capture Source",
10932                 .info = alc_mux_enum_info,
10933                 .get = alc_mux_enum_get,
10934                 .put = alc262_ultra_mux_enum_put,
10935         },
10936         { } /* end */
10937 };
10938
10939 /* We use two mixers depending on the output pin; 0x16 is a mono output
10940  * and thus it's bound with a different mixer.
10941  * This function returns which mixer amp should be used.
10942  */
10943 static int alc262_check_volbit(hda_nid_t nid)
10944 {
10945         if (!nid)
10946                 return 0;
10947         else if (nid == 0x16)
10948                 return 2;
10949         else
10950                 return 1;
10951 }
10952
10953 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
10954                                   const char *pfx, int *vbits)
10955 {
10956         char name[32];
10957         unsigned long val;
10958         int vbit;
10959
10960         vbit = alc262_check_volbit(nid);
10961         if (!vbit)
10962                 return 0;
10963         if (*vbits & vbit) /* a volume control for this mixer already there */
10964                 return 0;
10965         *vbits |= vbit;
10966         snprintf(name, sizeof(name), "%s Playback Volume", pfx);
10967         if (vbit == 2)
10968                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
10969         else
10970                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
10971         return add_control(spec, ALC_CTL_WIDGET_VOL, name, val);
10972 }
10973
10974 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
10975                                  const char *pfx)
10976 {
10977         char name[32];
10978         unsigned long val;
10979
10980         if (!nid)
10981                 return 0;
10982         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
10983         if (nid == 0x16)
10984                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
10985         else
10986                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
10987         return add_control(spec, ALC_CTL_WIDGET_MUTE, name, val);
10988 }
10989
10990 /* add playback controls from the parsed DAC table */
10991 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
10992                                              const struct auto_pin_cfg *cfg)
10993 {
10994         const char *pfx;
10995         int vbits;
10996         int err;
10997
10998         spec->multiout.num_dacs = 1;    /* only use one dac */
10999         spec->multiout.dac_nids = spec->private_dac_nids;
11000         spec->multiout.dac_nids[0] = 2;
11001
11002         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11003                 pfx = "Master";
11004         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11005                 pfx = "Speaker";
11006         else
11007                 pfx = "Front";
11008         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11009         if (err < 0)
11010                 return err;
11011         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11012         if (err < 0)
11013                 return err;
11014         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11015         if (err < 0)
11016                 return err;
11017
11018         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11019                 alc262_check_volbit(cfg->speaker_pins[0]) |
11020                 alc262_check_volbit(cfg->hp_pins[0]);
11021         if (vbits == 1 || vbits == 2)
11022                 pfx = "Master"; /* only one mixer is used */
11023         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11024                 pfx = "Speaker";
11025         else
11026                 pfx = "Front";
11027         vbits = 0;
11028         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11029         if (err < 0)
11030                 return err;
11031         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11032                                      &vbits);
11033         if (err < 0)
11034                 return err;
11035         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11036                                      &vbits);
11037         if (err < 0)
11038                 return err;
11039         return 0;
11040 }
11041
11042 #define alc262_auto_create_input_ctls \
11043         alc880_auto_create_input_ctls
11044
11045 /*
11046  * generic initialization of ADC, input mixers and output mixers
11047  */
11048 static struct hda_verb alc262_volume_init_verbs[] = {
11049         /*
11050          * Unmute ADC0-2 and set the default input to mic-in
11051          */
11052         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11053         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11054         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11055         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11056         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11057         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11058
11059         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11060          * mixer widget
11061          * Note: PASD motherboards uses the Line In 2 as the input for
11062          * front panel mic (mic 2)
11063          */
11064         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11065         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11066         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11067         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11068         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11069         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11070
11071         /*
11072          * Set up output mixers (0x0c - 0x0f)
11073          */
11074         /* set vol=0 to output mixers */
11075         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11076         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11077         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11078
11079         /* set up input amps for analog loopback */
11080         /* Amp Indices: DAC = 0, mixer = 1 */
11081         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11082         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11083         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11084         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11085         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11086         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11087
11088         /* FIXME: use matrix-type input source selection */
11089         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11090         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11091         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11092         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11093         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11094         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11095         /* Input mixer2 */
11096         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11097         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11098         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11099         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11100         /* Input mixer3 */
11101         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11102         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11103         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11104         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11105
11106         { }
11107 };
11108
11109 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11110         /*
11111          * Unmute ADC0-2 and set the default input to mic-in
11112          */
11113         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11114         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11115         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11116         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11117         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11118         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11119
11120         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11121          * mixer widget
11122          * Note: PASD motherboards uses the Line In 2 as the input for
11123          * front panel mic (mic 2)
11124          */
11125         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11126         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11127         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11128         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11129         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11130         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11131         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11132         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11133
11134         /*
11135          * Set up output mixers (0x0c - 0x0e)
11136          */
11137         /* set vol=0 to output mixers */
11138         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11139         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11140         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11141
11142         /* set up input amps for analog loopback */
11143         /* Amp Indices: DAC = 0, mixer = 1 */
11144         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11145         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11146         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11147         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11148         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11149         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11150
11151         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11152         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11153         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11154
11155         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11156         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11157
11158         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11159         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11160
11161         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11162         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11163         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11164         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11165         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11166
11167         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11168         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11169         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11170         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11171         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11172         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11173
11174
11175         /* FIXME: use matrix-type input source selection */
11176         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11177         /* Input mixer1: only unmute Mic */
11178         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11179         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11180         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11181         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11182         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11183         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11184         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11185         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11186         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11187         /* Input mixer2 */
11188         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11189         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11190         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11191         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11192         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11193         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11194         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11195         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11196         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11197         /* Input mixer3 */
11198         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11199         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11200         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11201         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11202         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11203         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11204         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11205         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11206         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11207
11208         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11209
11210         { }
11211 };
11212
11213 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11214         /*
11215          * Unmute ADC0-2 and set the default input to mic-in
11216          */
11217         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11218         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11219         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11220         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11221         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11222         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11223
11224         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11225          * mixer widget
11226          * Note: PASD motherboards uses the Line In 2 as the input for front
11227          * panel mic (mic 2)
11228          */
11229         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11230         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11231         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11232         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11233         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11234         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11235         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11236         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11237         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11238         /*
11239          * Set up output mixers (0x0c - 0x0e)
11240          */
11241         /* set vol=0 to output mixers */
11242         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11243         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11244         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11245
11246         /* set up input amps for analog loopback */
11247         /* Amp Indices: DAC = 0, mixer = 1 */
11248         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11249         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11250         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11251         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11252         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11253         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11254
11255
11256         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11257         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11258         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11259         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11260         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11261         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11262         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11263
11264         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11265         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11266
11267         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11268         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11269
11270         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11271         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11272         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11273         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11274         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11275         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11276
11277         /* FIXME: use matrix-type input source selection */
11278         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11279         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11280         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11281         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11282         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11283         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11284         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11285         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11287         /* Input mixer2 */
11288         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11289         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11290         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11291         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11292         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11293         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11294         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11295         /* Input mixer3 */
11296         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11298         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11299         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11300         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11301         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11302         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11303
11304         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11305
11306         { }
11307 };
11308
11309 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11310
11311         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11312         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11313         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11314
11315         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11316         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11317         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11318         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11319
11320         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11321         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11322         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11323         {}
11324 };
11325
11326
11327 #ifdef CONFIG_SND_HDA_POWER_SAVE
11328 #define alc262_loopbacks        alc880_loopbacks
11329 #endif
11330
11331 /* pcm configuration: identical with ALC880 */
11332 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11333 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11334 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11335 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11336
11337 /*
11338  * BIOS auto configuration
11339  */
11340 static int alc262_parse_auto_config(struct hda_codec *codec)
11341 {
11342         struct alc_spec *spec = codec->spec;
11343         int err;
11344         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11345
11346         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11347                                            alc262_ignore);
11348         if (err < 0)
11349                 return err;
11350         if (!spec->autocfg.line_outs) {
11351                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11352                         spec->multiout.max_channels = 2;
11353                         spec->no_analog = 1;
11354                         goto dig_only;
11355                 }
11356                 return 0; /* can't find valid BIOS pin config */
11357         }
11358         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11359         if (err < 0)
11360                 return err;
11361         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11362         if (err < 0)
11363                 return err;
11364
11365         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11366
11367  dig_only:
11368         if (spec->autocfg.dig_outs) {
11369                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11370                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11371         }
11372         if (spec->autocfg.dig_in_pin)
11373                 spec->dig_in_nid = ALC262_DIGIN_NID;
11374
11375         if (spec->kctls.list)
11376                 add_mixer(spec, spec->kctls.list);
11377
11378         add_verb(spec, alc262_volume_init_verbs);
11379         spec->num_mux_defs = 1;
11380         spec->input_mux = &spec->private_imux[0];
11381
11382         err = alc_auto_add_mic_boost(codec);
11383         if (err < 0)
11384                 return err;
11385
11386         alc_ssid_check(codec, 0x15, 0x14, 0x1b);
11387
11388         return 1;
11389 }
11390
11391 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11392 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11393 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11394 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11395
11396
11397 /* init callback for auto-configuration model -- overriding the default init */
11398 static void alc262_auto_init(struct hda_codec *codec)
11399 {
11400         struct alc_spec *spec = codec->spec;
11401         alc262_auto_init_multi_out(codec);
11402         alc262_auto_init_hp_out(codec);
11403         alc262_auto_init_analog_input(codec);
11404         alc262_auto_init_input_src(codec);
11405         if (spec->unsol_event)
11406                 alc_inithook(codec);
11407 }
11408
11409 /*
11410  * configuration and preset
11411  */
11412 static const char *alc262_models[ALC262_MODEL_LAST] = {
11413         [ALC262_BASIC]          = "basic",
11414         [ALC262_HIPPO]          = "hippo",
11415         [ALC262_HIPPO_1]        = "hippo_1",
11416         [ALC262_FUJITSU]        = "fujitsu",
11417         [ALC262_HP_BPC]         = "hp-bpc",
11418         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11419         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11420         [ALC262_HP_RP5700]      = "hp-rp5700",
11421         [ALC262_BENQ_ED8]       = "benq",
11422         [ALC262_BENQ_T31]       = "benq-t31",
11423         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11424         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11425         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11426         [ALC262_ULTRA]          = "ultra",
11427         [ALC262_LENOVO_3000]    = "lenovo-3000",
11428         [ALC262_NEC]            = "nec",
11429         [ALC262_TYAN]           = "tyan",
11430         [ALC262_AUTO]           = "auto",
11431 };
11432
11433 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11434         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11435         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11436         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11437                            ALC262_HP_BPC),
11438         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11439                            ALC262_HP_BPC),
11440         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11441                            ALC262_HP_BPC),
11442         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11443         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11444         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11445         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11446         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11447         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11448         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11449         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11450         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11451         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11452         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11453         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11454                       ALC262_HP_TC_T5735),
11455         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11456         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11457         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11458         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11459         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11460         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11461         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
11462                            ALC262_SONY_ASSAMD),
11463         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
11464                       ALC262_TOSHIBA_RX1),
11465         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
11466         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
11467         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
11468         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
11469         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
11470                            ALC262_ULTRA),
11471         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
11472         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
11473         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
11474         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
11475         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
11476         {}
11477 };
11478
11479 static struct alc_config_preset alc262_presets[] = {
11480         [ALC262_BASIC] = {
11481                 .mixers = { alc262_base_mixer },
11482                 .init_verbs = { alc262_init_verbs },
11483                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11484                 .dac_nids = alc262_dac_nids,
11485                 .hp_nid = 0x03,
11486                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11487                 .channel_mode = alc262_modes,
11488                 .input_mux = &alc262_capture_source,
11489         },
11490         [ALC262_HIPPO] = {
11491                 .mixers = { alc262_hippo_mixer },
11492                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
11493                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11494                 .dac_nids = alc262_dac_nids,
11495                 .hp_nid = 0x03,
11496                 .dig_out_nid = ALC262_DIGOUT_NID,
11497                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11498                 .channel_mode = alc262_modes,
11499                 .input_mux = &alc262_capture_source,
11500                 .unsol_event = alc262_hippo_unsol_event,
11501                 .setup = alc262_hippo_setup,
11502                 .init_hook = alc262_hippo_automute,
11503         },
11504         [ALC262_HIPPO_1] = {
11505                 .mixers = { alc262_hippo1_mixer },
11506                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
11507                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11508                 .dac_nids = alc262_dac_nids,
11509                 .hp_nid = 0x02,
11510                 .dig_out_nid = ALC262_DIGOUT_NID,
11511                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11512                 .channel_mode = alc262_modes,
11513                 .input_mux = &alc262_capture_source,
11514                 .unsol_event = alc262_hippo_unsol_event,
11515                 .setup = alc262_hippo1_setup,
11516                 .init_hook = alc262_hippo_automute,
11517         },
11518         [ALC262_FUJITSU] = {
11519                 .mixers = { alc262_fujitsu_mixer },
11520                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11521                                 alc262_fujitsu_unsol_verbs },
11522                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11523                 .dac_nids = alc262_dac_nids,
11524                 .hp_nid = 0x03,
11525                 .dig_out_nid = ALC262_DIGOUT_NID,
11526                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11527                 .channel_mode = alc262_modes,
11528                 .input_mux = &alc262_fujitsu_capture_source,
11529                 .unsol_event = alc262_fujitsu_unsol_event,
11530                 .init_hook = alc262_fujitsu_init_hook,
11531         },
11532         [ALC262_HP_BPC] = {
11533                 .mixers = { alc262_HP_BPC_mixer },
11534                 .init_verbs = { alc262_HP_BPC_init_verbs },
11535                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11536                 .dac_nids = alc262_dac_nids,
11537                 .hp_nid = 0x03,
11538                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11539                 .channel_mode = alc262_modes,
11540                 .input_mux = &alc262_HP_capture_source,
11541                 .unsol_event = alc262_hp_bpc_unsol_event,
11542                 .init_hook = alc262_hp_bpc_automute,
11543         },
11544         [ALC262_HP_BPC_D7000_WF] = {
11545                 .mixers = { alc262_HP_BPC_WildWest_mixer },
11546                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11547                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11548                 .dac_nids = alc262_dac_nids,
11549                 .hp_nid = 0x03,
11550                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11551                 .channel_mode = alc262_modes,
11552                 .input_mux = &alc262_HP_D7000_capture_source,
11553                 .unsol_event = alc262_hp_wildwest_unsol_event,
11554                 .init_hook = alc262_hp_wildwest_automute,
11555         },
11556         [ALC262_HP_BPC_D7000_WL] = {
11557                 .mixers = { alc262_HP_BPC_WildWest_mixer,
11558                             alc262_HP_BPC_WildWest_option_mixer },
11559                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
11560                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11561                 .dac_nids = alc262_dac_nids,
11562                 .hp_nid = 0x03,
11563                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11564                 .channel_mode = alc262_modes,
11565                 .input_mux = &alc262_HP_D7000_capture_source,
11566                 .unsol_event = alc262_hp_wildwest_unsol_event,
11567                 .init_hook = alc262_hp_wildwest_automute,
11568         },
11569         [ALC262_HP_TC_T5735] = {
11570                 .mixers = { alc262_hp_t5735_mixer },
11571                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
11572                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11573                 .dac_nids = alc262_dac_nids,
11574                 .hp_nid = 0x03,
11575                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11576                 .channel_mode = alc262_modes,
11577                 .input_mux = &alc262_capture_source,
11578                 .unsol_event = alc_automute_amp_unsol_event,
11579                 .setup = alc262_hp_t5735_setup,
11580                 .init_hook = alc_automute_amp,
11581         },
11582         [ALC262_HP_RP5700] = {
11583                 .mixers = { alc262_hp_rp5700_mixer },
11584                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
11585                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11586                 .dac_nids = alc262_dac_nids,
11587                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11588                 .channel_mode = alc262_modes,
11589                 .input_mux = &alc262_hp_rp5700_capture_source,
11590         },
11591         [ALC262_BENQ_ED8] = {
11592                 .mixers = { alc262_base_mixer },
11593                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
11594                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11595                 .dac_nids = alc262_dac_nids,
11596                 .hp_nid = 0x03,
11597                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11598                 .channel_mode = alc262_modes,
11599                 .input_mux = &alc262_capture_source,
11600         },
11601         [ALC262_SONY_ASSAMD] = {
11602                 .mixers = { alc262_sony_mixer },
11603                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
11604                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11605                 .dac_nids = alc262_dac_nids,
11606                 .hp_nid = 0x02,
11607                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11608                 .channel_mode = alc262_modes,
11609                 .input_mux = &alc262_capture_source,
11610                 .unsol_event = alc262_hippo_unsol_event,
11611                 .setup = alc262_hippo_setup,
11612                 .init_hook = alc262_hippo_automute,
11613         },
11614         [ALC262_BENQ_T31] = {
11615                 .mixers = { alc262_benq_t31_mixer },
11616                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
11617                                 alc_hp15_unsol_verbs },
11618                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11619                 .dac_nids = alc262_dac_nids,
11620                 .hp_nid = 0x03,
11621                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11622                 .channel_mode = alc262_modes,
11623                 .input_mux = &alc262_capture_source,
11624                 .unsol_event = alc262_hippo_unsol_event,
11625                 .setup = alc262_hippo_setup,
11626                 .init_hook = alc262_hippo_automute,
11627         },
11628         [ALC262_ULTRA] = {
11629                 .mixers = { alc262_ultra_mixer },
11630                 .cap_mixer = alc262_ultra_capture_mixer,
11631                 .init_verbs = { alc262_ultra_verbs },
11632                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11633                 .dac_nids = alc262_dac_nids,
11634                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11635                 .channel_mode = alc262_modes,
11636                 .input_mux = &alc262_ultra_capture_source,
11637                 .adc_nids = alc262_adc_nids, /* ADC0 */
11638                 .capsrc_nids = alc262_capsrc_nids,
11639                 .num_adc_nids = 1, /* single ADC */
11640                 .unsol_event = alc262_ultra_unsol_event,
11641                 .init_hook = alc262_ultra_automute,
11642         },
11643         [ALC262_LENOVO_3000] = {
11644                 .mixers = { alc262_lenovo_3000_mixer },
11645                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
11646                                 alc262_lenovo_3000_unsol_verbs },
11647                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11648                 .dac_nids = alc262_dac_nids,
11649                 .hp_nid = 0x03,
11650                 .dig_out_nid = ALC262_DIGOUT_NID,
11651                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11652                 .channel_mode = alc262_modes,
11653                 .input_mux = &alc262_fujitsu_capture_source,
11654                 .unsol_event = alc262_lenovo_3000_unsol_event,
11655         },
11656         [ALC262_NEC] = {
11657                 .mixers = { alc262_nec_mixer },
11658                 .init_verbs = { alc262_nec_verbs },
11659                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11660                 .dac_nids = alc262_dac_nids,
11661                 .hp_nid = 0x03,
11662                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11663                 .channel_mode = alc262_modes,
11664                 .input_mux = &alc262_capture_source,
11665         },
11666         [ALC262_TOSHIBA_S06] = {
11667                 .mixers = { alc262_toshiba_s06_mixer },
11668                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
11669                                                         alc262_eapd_verbs },
11670                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11671                 .capsrc_nids = alc262_dmic_capsrc_nids,
11672                 .dac_nids = alc262_dac_nids,
11673                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
11674                 .num_adc_nids = 1, /* single ADC */
11675                 .dig_out_nid = ALC262_DIGOUT_NID,
11676                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11677                 .channel_mode = alc262_modes,
11678                 .unsol_event = alc_sku_unsol_event,
11679                 .setup = alc262_toshiba_s06_setup,
11680                 .init_hook = alc_inithook,
11681         },
11682         [ALC262_TOSHIBA_RX1] = {
11683                 .mixers = { alc262_toshiba_rx1_mixer },
11684                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
11685                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11686                 .dac_nids = alc262_dac_nids,
11687                 .hp_nid = 0x03,
11688                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11689                 .channel_mode = alc262_modes,
11690                 .input_mux = &alc262_capture_source,
11691                 .unsol_event = alc262_hippo_unsol_event,
11692                 .setup = alc262_hippo_setup,
11693                 .init_hook = alc262_hippo_automute,
11694         },
11695         [ALC262_TYAN] = {
11696                 .mixers = { alc262_tyan_mixer },
11697                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
11698                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
11699                 .dac_nids = alc262_dac_nids,
11700                 .hp_nid = 0x02,
11701                 .dig_out_nid = ALC262_DIGOUT_NID,
11702                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
11703                 .channel_mode = alc262_modes,
11704                 .input_mux = &alc262_capture_source,
11705                 .unsol_event = alc_automute_amp_unsol_event,
11706                 .setup = alc262_tyan_setup,
11707                 .init_hook = alc_automute_amp,
11708         },
11709 };
11710
11711 static int patch_alc262(struct hda_codec *codec)
11712 {
11713         struct alc_spec *spec;
11714         int board_config;
11715         int err;
11716
11717         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
11718         if (spec == NULL)
11719                 return -ENOMEM;
11720
11721         codec->spec = spec;
11722 #if 0
11723         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
11724          * under-run
11725          */
11726         {
11727         int tmp;
11728         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11729         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
11730         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
11731         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
11732         }
11733 #endif
11734
11735         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
11736
11737         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
11738                                                   alc262_models,
11739                                                   alc262_cfg_tbl);
11740
11741         if (board_config < 0) {
11742                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
11743                        codec->chip_name);
11744                 board_config = ALC262_AUTO;
11745         }
11746
11747         if (board_config == ALC262_AUTO) {
11748                 /* automatic parse from the BIOS config */
11749                 err = alc262_parse_auto_config(codec);
11750                 if (err < 0) {
11751                         alc_free(codec);
11752                         return err;
11753                 } else if (!err) {
11754                         printk(KERN_INFO
11755                                "hda_codec: Cannot set up configuration "
11756                                "from BIOS.  Using base mode...\n");
11757                         board_config = ALC262_BASIC;
11758                 }
11759         }
11760
11761         if (!spec->no_analog) {
11762                 err = snd_hda_attach_beep_device(codec, 0x1);
11763                 if (err < 0) {
11764                         alc_free(codec);
11765                         return err;
11766                 }
11767         }
11768
11769         if (board_config != ALC262_AUTO)
11770                 setup_preset(codec, &alc262_presets[board_config]);
11771
11772         spec->stream_analog_playback = &alc262_pcm_analog_playback;
11773         spec->stream_analog_capture = &alc262_pcm_analog_capture;
11774
11775         spec->stream_digital_playback = &alc262_pcm_digital_playback;
11776         spec->stream_digital_capture = &alc262_pcm_digital_capture;
11777
11778         if (!spec->adc_nids && spec->input_mux) {
11779                 int i;
11780                 /* check whether the digital-mic has to be supported */
11781                 for (i = 0; i < spec->input_mux->num_items; i++) {
11782                         if (spec->input_mux->items[i].index >= 9)
11783                                 break;
11784                 }
11785                 if (i < spec->input_mux->num_items) {
11786                         /* use only ADC0 */
11787                         spec->adc_nids = alc262_dmic_adc_nids;
11788                         spec->num_adc_nids = 1;
11789                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
11790                 } else {
11791                         /* all analog inputs */
11792                         /* check whether NID 0x07 is valid */
11793                         unsigned int wcap = get_wcaps(codec, 0x07);
11794
11795                         /* get type */
11796                         wcap = get_wcaps_type(wcap);
11797                         if (wcap != AC_WID_AUD_IN) {
11798                                 spec->adc_nids = alc262_adc_nids_alt;
11799                                 spec->num_adc_nids =
11800                                         ARRAY_SIZE(alc262_adc_nids_alt);
11801                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
11802                         } else {
11803                                 spec->adc_nids = alc262_adc_nids;
11804                                 spec->num_adc_nids =
11805                                         ARRAY_SIZE(alc262_adc_nids);
11806                                 spec->capsrc_nids = alc262_capsrc_nids;
11807                         }
11808                 }
11809         }
11810         if (!spec->cap_mixer && !spec->no_analog)
11811                 set_capture_mixer(codec);
11812         if (!spec->no_analog)
11813                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
11814
11815         spec->vmaster_nid = 0x0c;
11816
11817         codec->patch_ops = alc_patch_ops;
11818         if (board_config == ALC262_AUTO)
11819                 spec->init_hook = alc262_auto_init;
11820 #ifdef CONFIG_SND_HDA_POWER_SAVE
11821         if (!spec->loopback.amplist)
11822                 spec->loopback.amplist = alc262_loopbacks;
11823 #endif
11824         codec->proc_widget_hook = print_realtek_coef;
11825
11826         return 0;
11827 }
11828
11829 /*
11830  *  ALC268 channel source setting (2 channel)
11831  */
11832 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
11833 #define alc268_modes            alc260_modes
11834
11835 static hda_nid_t alc268_dac_nids[2] = {
11836         /* front, hp */
11837         0x02, 0x03
11838 };
11839
11840 static hda_nid_t alc268_adc_nids[2] = {
11841         /* ADC0-1 */
11842         0x08, 0x07
11843 };
11844
11845 static hda_nid_t alc268_adc_nids_alt[1] = {
11846         /* ADC0 */
11847         0x08
11848 };
11849
11850 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
11851
11852 static struct snd_kcontrol_new alc268_base_mixer[] = {
11853         /* output mixer control */
11854         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11855         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11856         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11857         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11858         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11859         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11860         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11861         { }
11862 };
11863
11864 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
11865         /* output mixer control */
11866         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
11867         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
11868         ALC262_HIPPO_MASTER_SWITCH,
11869         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11870         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11871         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11872         { }
11873 };
11874
11875 /* bind Beep switches of both NID 0x0f and 0x10 */
11876 static struct hda_bind_ctls alc268_bind_beep_sw = {
11877         .ops = &snd_hda_bind_sw,
11878         .values = {
11879                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
11880                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
11881                 0
11882         },
11883 };
11884
11885 static struct snd_kcontrol_new alc268_beep_mixer[] = {
11886         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
11887         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
11888         { }
11889 };
11890
11891 static struct hda_verb alc268_eapd_verbs[] = {
11892         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11893         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11894         { }
11895 };
11896
11897 /* Toshiba specific */
11898 static struct hda_verb alc268_toshiba_verbs[] = {
11899         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11900         { } /* end */
11901 };
11902
11903 /* Acer specific */
11904 /* bind volumes of both NID 0x02 and 0x03 */
11905 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
11906         .ops = &snd_hda_bind_vol,
11907         .values = {
11908                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
11909                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
11910                 0
11911         },
11912 };
11913
11914 /* mute/unmute internal speaker according to the hp jack and mute state */
11915 static void alc268_acer_automute(struct hda_codec *codec, int force)
11916 {
11917         struct alc_spec *spec = codec->spec;
11918         unsigned int mute;
11919
11920         if (force || !spec->sense_updated) {
11921                 unsigned int present;
11922                 present = snd_hda_codec_read(codec, 0x14, 0,
11923                                          AC_VERB_GET_PIN_SENSE, 0);
11924                 spec->jack_present = (present & 0x80000000) != 0;
11925                 spec->sense_updated = 1;
11926         }
11927         if (spec->jack_present)
11928                 mute = HDA_AMP_MUTE; /* mute internal speaker */
11929         else /* unmute internal speaker if necessary */
11930                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11931         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11932                                  HDA_AMP_MUTE, mute);
11933 }
11934
11935
11936 /* bind hp and internal speaker mute (with plug check) */
11937 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
11938                                      struct snd_ctl_elem_value *ucontrol)
11939 {
11940         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11941         long *valp = ucontrol->value.integer.value;
11942         int change;
11943
11944         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11945         if (change)
11946                 alc268_acer_automute(codec, 0);
11947         return change;
11948 }
11949
11950 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
11951         /* output mixer control */
11952         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11953         {
11954                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11955                 .name = "Master Playback Switch",
11956                 .info = snd_hda_mixer_amp_switch_info,
11957                 .get = snd_hda_mixer_amp_switch_get,
11958                 .put = alc268_acer_master_sw_put,
11959                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11960         },
11961         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
11962         { }
11963 };
11964
11965 static struct snd_kcontrol_new alc268_acer_mixer[] = {
11966         /* output mixer control */
11967         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11968         {
11969                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11970                 .name = "Master Playback Switch",
11971                 .info = snd_hda_mixer_amp_switch_info,
11972                 .get = snd_hda_mixer_amp_switch_get,
11973                 .put = alc268_acer_master_sw_put,
11974                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11975         },
11976         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11977         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
11978         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11979         { }
11980 };
11981
11982 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
11983         /* output mixer control */
11984         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
11985         {
11986                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11987                 .name = "Master Playback Switch",
11988                 .info = snd_hda_mixer_amp_switch_info,
11989                 .get = snd_hda_mixer_amp_switch_get,
11990                 .put = alc268_acer_master_sw_put,
11991                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11992         },
11993         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11994         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
11995         { }
11996 };
11997
11998 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
11999         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12000         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12001         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12002         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12003         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12004         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12005         { }
12006 };
12007
12008 static struct hda_verb alc268_acer_verbs[] = {
12009         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12010         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12011         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12012         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12013         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12014         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12015         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12016         { }
12017 };
12018
12019 /* unsolicited event for HP jack sensing */
12020 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12021 #define alc268_toshiba_setup            alc262_hippo_setup
12022 #define alc268_toshiba_automute         alc262_hippo_automute
12023
12024 static void alc268_acer_unsol_event(struct hda_codec *codec,
12025                                        unsigned int res)
12026 {
12027         if ((res >> 26) != ALC880_HP_EVENT)
12028                 return;
12029         alc268_acer_automute(codec, 1);
12030 }
12031
12032 static void alc268_acer_init_hook(struct hda_codec *codec)
12033 {
12034         alc268_acer_automute(codec, 1);
12035 }
12036
12037 /* toggle speaker-output according to the hp-jack state */
12038 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12039 {
12040         unsigned int present;
12041         unsigned char bits;
12042
12043         present = snd_hda_codec_read(codec, 0x15, 0,
12044                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
12045         bits = present ? AMP_IN_MUTE(0) : 0;
12046         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12047                                 AMP_IN_MUTE(0), bits);
12048         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12049                                 AMP_IN_MUTE(0), bits);
12050 }
12051
12052 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12053                                     unsigned int res)
12054 {
12055         switch (res >> 26) {
12056         case ALC880_HP_EVENT:
12057                 alc268_aspire_one_speaker_automute(codec);
12058                 break;
12059         case ALC880_MIC_EVENT:
12060                 alc_mic_automute(codec);
12061                 break;
12062         }
12063 }
12064
12065 static void alc268_acer_lc_setup(struct hda_codec *codec)
12066 {
12067         struct alc_spec *spec = codec->spec;
12068         spec->ext_mic.pin = 0x18;
12069         spec->ext_mic.mux_idx = 0;
12070         spec->int_mic.pin = 0x12;
12071         spec->int_mic.mux_idx = 6;
12072         spec->auto_mic = 1;
12073 }
12074
12075 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12076 {
12077         alc268_aspire_one_speaker_automute(codec);
12078         alc_mic_automute(codec);
12079 }
12080
12081 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12082         /* output mixer control */
12083         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12084         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12085         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12086         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12087         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12088         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12089         { }
12090 };
12091
12092 static struct hda_verb alc268_dell_verbs[] = {
12093         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12094         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12095         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12096         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12097         { }
12098 };
12099
12100 /* mute/unmute internal speaker according to the hp jack and mute state */
12101 static void alc268_dell_setup(struct hda_codec *codec)
12102 {
12103         struct alc_spec *spec = codec->spec;
12104
12105         spec->autocfg.hp_pins[0] = 0x15;
12106         spec->autocfg.speaker_pins[0] = 0x14;
12107         spec->ext_mic.pin = 0x18;
12108         spec->ext_mic.mux_idx = 0;
12109         spec->int_mic.pin = 0x19;
12110         spec->int_mic.mux_idx = 1;
12111         spec->auto_mic = 1;
12112 }
12113
12114 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12115         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12116         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12117         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12118         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12119         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12120         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12121         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12122         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12123         { }
12124 };
12125
12126 static struct hda_verb alc267_quanta_il1_verbs[] = {
12127         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12128         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12129         { }
12130 };
12131
12132 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12133 {
12134         struct alc_spec *spec = codec->spec;
12135         spec->autocfg.hp_pins[0] = 0x15;
12136         spec->autocfg.speaker_pins[0] = 0x14;
12137         spec->ext_mic.pin = 0x18;
12138         spec->ext_mic.mux_idx = 0;
12139         spec->int_mic.pin = 0x19;
12140         spec->int_mic.mux_idx = 1;
12141         spec->auto_mic = 1;
12142 }
12143
12144 /*
12145  * generic initialization of ADC, input mixers and output mixers
12146  */
12147 static struct hda_verb alc268_base_init_verbs[] = {
12148         /* Unmute DAC0-1 and set vol = 0 */
12149         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12150         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12151
12152         /*
12153          * Set up output mixers (0x0c - 0x0e)
12154          */
12155         /* set vol=0 to output mixers */
12156         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12157         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12158
12159         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12160         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12161
12162         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12163         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12164         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12165         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12166         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12167         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12168         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12169         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12170
12171         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12172         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12173         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12174         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12175         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12176
12177         /* set PCBEEP vol = 0, mute connections */
12178         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12179         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12180         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12181
12182         /* Unmute Selector 23h,24h and set the default input to mic-in */
12183
12184         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12185         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12186         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12187         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12188
12189         { }
12190 };
12191
12192 /*
12193  * generic initialization of ADC, input mixers and output mixers
12194  */
12195 static struct hda_verb alc268_volume_init_verbs[] = {
12196         /* set output DAC */
12197         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12198         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12199
12200         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12201         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12202         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12203         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12204         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12205
12206         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12207         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12208         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12209
12210         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12211         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12212
12213         /* set PCBEEP vol = 0, mute connections */
12214         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12215         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12216         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12217
12218         { }
12219 };
12220
12221 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12222         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12223         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12224         { } /* end */
12225 };
12226
12227 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12228         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12229         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12230         _DEFINE_CAPSRC(1),
12231         { } /* end */
12232 };
12233
12234 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12235         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12236         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12237         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12238         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12239         _DEFINE_CAPSRC(2),
12240         { } /* end */
12241 };
12242
12243 static struct hda_input_mux alc268_capture_source = {
12244         .num_items = 4,
12245         .items = {
12246                 { "Mic", 0x0 },
12247                 { "Front Mic", 0x1 },
12248                 { "Line", 0x2 },
12249                 { "CD", 0x3 },
12250         },
12251 };
12252
12253 static struct hda_input_mux alc268_acer_capture_source = {
12254         .num_items = 3,
12255         .items = {
12256                 { "Mic", 0x0 },
12257                 { "Internal Mic", 0x1 },
12258                 { "Line", 0x2 },
12259         },
12260 };
12261
12262 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12263         .num_items = 3,
12264         .items = {
12265                 { "Mic", 0x0 },
12266                 { "Internal Mic", 0x6 },
12267                 { "Line", 0x2 },
12268         },
12269 };
12270
12271 #ifdef CONFIG_SND_DEBUG
12272 static struct snd_kcontrol_new alc268_test_mixer[] = {
12273         /* Volume widgets */
12274         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12275         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12276         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12277         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12278         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12279         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12280         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12281         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12282         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12283         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12284         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12285         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12286         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12287         /* The below appears problematic on some hardwares */
12288         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12289         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12290         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12291         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12292         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12293
12294         /* Modes for retasking pin widgets */
12295         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12296         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12297         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12298         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12299
12300         /* Controls for GPIO pins, assuming they are configured as outputs */
12301         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12302         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12303         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12304         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12305
12306         /* Switches to allow the digital SPDIF output pin to be enabled.
12307          * The ALC268 does not have an SPDIF input.
12308          */
12309         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12310
12311         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12312          * this output to turn on an external amplifier.
12313          */
12314         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12315         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12316
12317         { } /* end */
12318 };
12319 #endif
12320
12321 /* create input playback/capture controls for the given pin */
12322 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12323                                     const char *ctlname, int idx)
12324 {
12325         char name[32];
12326         hda_nid_t dac;
12327         int err;
12328
12329         sprintf(name, "%s Playback Volume", ctlname);
12330         switch (nid) {
12331         case 0x14:
12332         case 0x16:
12333                 dac = 0x02;
12334                 break;
12335         case 0x15:
12336                 dac = 0x03;
12337                 break;
12338         default:
12339                 return 0;
12340         }
12341         if (spec->multiout.dac_nids[0] != dac &&
12342             spec->multiout.dac_nids[1] != dac) {
12343                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
12344                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12345                                                       HDA_OUTPUT));
12346                 if (err < 0)
12347                         return err;
12348                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12349         }
12350
12351         sprintf(name, "%s Playback Switch", ctlname);
12352         if (nid != 0x16)
12353                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12354                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12355         else /* mono */
12356                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
12357                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12358         if (err < 0)
12359                 return err;
12360         return 0;
12361 }
12362
12363 /* add playback controls from the parsed DAC table */
12364 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12365                                              const struct auto_pin_cfg *cfg)
12366 {
12367         hda_nid_t nid;
12368         int err;
12369
12370         spec->multiout.dac_nids = spec->private_dac_nids;
12371
12372         nid = cfg->line_out_pins[0];
12373         if (nid) {
12374                 const char *name;
12375                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12376                         name = "Speaker";
12377                 else
12378                         name = "Front";
12379                 err = alc268_new_analog_output(spec, nid, name, 0);
12380                 if (err < 0)
12381                         return err;
12382         }
12383
12384         nid = cfg->speaker_pins[0];
12385         if (nid == 0x1d) {
12386                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
12387                                   "Speaker Playback Volume",
12388                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12389                 if (err < 0)
12390                         return err;
12391         } else {
12392                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12393                 if (err < 0)
12394                         return err;
12395         }
12396         nid = cfg->hp_pins[0];
12397         if (nid) {
12398                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12399                 if (err < 0)
12400                         return err;
12401         }
12402
12403         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12404         if (nid == 0x16) {
12405                 err = add_control(spec, ALC_CTL_WIDGET_MUTE,
12406                                   "Mono Playback Switch",
12407                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12408                 if (err < 0)
12409                         return err;
12410         }
12411         return 0;
12412 }
12413
12414 /* create playback/capture controls for input pins */
12415 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12416                                                 const struct auto_pin_cfg *cfg)
12417 {
12418         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12419 }
12420
12421 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12422                                               hda_nid_t nid, int pin_type)
12423 {
12424         int idx;
12425
12426         alc_set_pin_output(codec, nid, pin_type);
12427         if (nid == 0x14 || nid == 0x16)
12428                 idx = 0;
12429         else
12430                 idx = 1;
12431         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12432 }
12433
12434 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12435 {
12436         struct alc_spec *spec = codec->spec;
12437         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12438         if (nid) {
12439                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12440                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12441         }
12442 }
12443
12444 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12445 {
12446         struct alc_spec *spec = codec->spec;
12447         hda_nid_t pin;
12448
12449         pin = spec->autocfg.hp_pins[0];
12450         if (pin)
12451                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12452         pin = spec->autocfg.speaker_pins[0];
12453         if (pin)
12454                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12455 }
12456
12457 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12458 {
12459         struct alc_spec *spec = codec->spec;
12460         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12461         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12462         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12463         unsigned int    dac_vol1, dac_vol2;
12464
12465         if (line_nid == 0x1d || speaker_nid == 0x1d) {
12466                 snd_hda_codec_write(codec, speaker_nid, 0,
12467                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
12468                 /* mute mixer inputs from 0x1d */
12469                 snd_hda_codec_write(codec, 0x0f, 0,
12470                                     AC_VERB_SET_AMP_GAIN_MUTE,
12471                                     AMP_IN_UNMUTE(1));
12472                 snd_hda_codec_write(codec, 0x10, 0,
12473                                     AC_VERB_SET_AMP_GAIN_MUTE,
12474                                     AMP_IN_UNMUTE(1));
12475         } else {
12476                 /* unmute mixer inputs from 0x1d */
12477                 snd_hda_codec_write(codec, 0x0f, 0,
12478                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12479                 snd_hda_codec_write(codec, 0x10, 0,
12480                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
12481         }
12482
12483         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
12484         if (line_nid == 0x14)
12485                 dac_vol2 = AMP_OUT_ZERO;
12486         else if (line_nid == 0x15)
12487                 dac_vol1 = AMP_OUT_ZERO;
12488         if (hp_nid == 0x14)
12489                 dac_vol2 = AMP_OUT_ZERO;
12490         else if (hp_nid == 0x15)
12491                 dac_vol1 = AMP_OUT_ZERO;
12492         if (line_nid != 0x16 || hp_nid != 0x16 ||
12493             spec->autocfg.line_out_pins[1] != 0x16 ||
12494             spec->autocfg.line_out_pins[2] != 0x16)
12495                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
12496
12497         snd_hda_codec_write(codec, 0x02, 0,
12498                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
12499         snd_hda_codec_write(codec, 0x03, 0,
12500                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
12501 }
12502
12503 /* pcm configuration: identical with ALC880 */
12504 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
12505 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
12506 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
12507 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
12508
12509 /*
12510  * BIOS auto configuration
12511  */
12512 static int alc268_parse_auto_config(struct hda_codec *codec)
12513 {
12514         struct alc_spec *spec = codec->spec;
12515         int err;
12516         static hda_nid_t alc268_ignore[] = { 0 };
12517
12518         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
12519                                            alc268_ignore);
12520         if (err < 0)
12521                 return err;
12522         if (!spec->autocfg.line_outs) {
12523                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
12524                         spec->multiout.max_channels = 2;
12525                         spec->no_analog = 1;
12526                         goto dig_only;
12527                 }
12528                 return 0; /* can't find valid BIOS pin config */
12529         }
12530         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
12531         if (err < 0)
12532                 return err;
12533         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
12534         if (err < 0)
12535                 return err;
12536
12537         spec->multiout.max_channels = 2;
12538
12539  dig_only:
12540         /* digital only support output */
12541         if (spec->autocfg.dig_outs) {
12542                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
12543                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
12544         }
12545         if (spec->kctls.list)
12546                 add_mixer(spec, spec->kctls.list);
12547
12548         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
12549                 add_mixer(spec, alc268_beep_mixer);
12550
12551         add_verb(spec, alc268_volume_init_verbs);
12552         spec->num_mux_defs = 2;
12553         spec->input_mux = &spec->private_imux[0];
12554
12555         err = alc_auto_add_mic_boost(codec);
12556         if (err < 0)
12557                 return err;
12558
12559         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
12560
12561         return 1;
12562 }
12563
12564 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
12565
12566 /* init callback for auto-configuration model -- overriding the default init */
12567 static void alc268_auto_init(struct hda_codec *codec)
12568 {
12569         struct alc_spec *spec = codec->spec;
12570         alc268_auto_init_multi_out(codec);
12571         alc268_auto_init_hp_out(codec);
12572         alc268_auto_init_mono_speaker_out(codec);
12573         alc268_auto_init_analog_input(codec);
12574         if (spec->unsol_event)
12575                 alc_inithook(codec);
12576 }
12577
12578 /*
12579  * configuration and preset
12580  */
12581 static const char *alc268_models[ALC268_MODEL_LAST] = {
12582         [ALC267_QUANTA_IL1]     = "quanta-il1",
12583         [ALC268_3ST]            = "3stack",
12584         [ALC268_TOSHIBA]        = "toshiba",
12585         [ALC268_ACER]           = "acer",
12586         [ALC268_ACER_DMIC]      = "acer-dmic",
12587         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
12588         [ALC268_DELL]           = "dell",
12589         [ALC268_ZEPTO]          = "zepto",
12590 #ifdef CONFIG_SND_DEBUG
12591         [ALC268_TEST]           = "test",
12592 #endif
12593         [ALC268_AUTO]           = "auto",
12594 };
12595
12596 static struct snd_pci_quirk alc268_cfg_tbl[] = {
12597         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
12598         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
12599         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
12600         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
12601         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
12602         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
12603                                                 ALC268_ACER_ASPIRE_ONE),
12604         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
12605         SND_PCI_QUIRK(0x1028, 0x02b0, "Dell Inspiron Mini9", ALC268_DELL),
12606         /* almost compatible with toshiba but with optional digital outs;
12607          * auto-probing seems working fine
12608          */
12609         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
12610                            ALC268_AUTO),
12611         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
12612         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
12613         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
12614         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
12615         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
12616         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
12617         {}
12618 };
12619
12620 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
12621 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
12622         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
12623         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
12624         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
12625                            ALC268_TOSHIBA),
12626         {}
12627 };
12628
12629 static struct alc_config_preset alc268_presets[] = {
12630         [ALC267_QUANTA_IL1] = {
12631                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
12632                             alc268_capture_nosrc_mixer },
12633                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12634                                 alc267_quanta_il1_verbs },
12635                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12636                 .dac_nids = alc268_dac_nids,
12637                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12638                 .adc_nids = alc268_adc_nids_alt,
12639                 .hp_nid = 0x03,
12640                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12641                 .channel_mode = alc268_modes,
12642                 .unsol_event = alc_sku_unsol_event,
12643                 .setup = alc267_quanta_il1_setup,
12644                 .init_hook = alc_inithook,
12645         },
12646         [ALC268_3ST] = {
12647                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12648                             alc268_beep_mixer },
12649                 .init_verbs = { alc268_base_init_verbs },
12650                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12651                 .dac_nids = alc268_dac_nids,
12652                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12653                 .adc_nids = alc268_adc_nids_alt,
12654                 .capsrc_nids = alc268_capsrc_nids,
12655                 .hp_nid = 0x03,
12656                 .dig_out_nid = ALC268_DIGOUT_NID,
12657                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12658                 .channel_mode = alc268_modes,
12659                 .input_mux = &alc268_capture_source,
12660         },
12661         [ALC268_TOSHIBA] = {
12662                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
12663                             alc268_beep_mixer },
12664                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12665                                 alc268_toshiba_verbs },
12666                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12667                 .dac_nids = alc268_dac_nids,
12668                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12669                 .adc_nids = alc268_adc_nids_alt,
12670                 .capsrc_nids = alc268_capsrc_nids,
12671                 .hp_nid = 0x03,
12672                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12673                 .channel_mode = alc268_modes,
12674                 .input_mux = &alc268_capture_source,
12675                 .unsol_event = alc268_toshiba_unsol_event,
12676                 .setup = alc268_toshiba_setup,
12677                 .init_hook = alc268_toshiba_automute,
12678         },
12679         [ALC268_ACER] = {
12680                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
12681                             alc268_beep_mixer },
12682                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12683                                 alc268_acer_verbs },
12684                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12685                 .dac_nids = alc268_dac_nids,
12686                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12687                 .adc_nids = alc268_adc_nids_alt,
12688                 .capsrc_nids = alc268_capsrc_nids,
12689                 .hp_nid = 0x02,
12690                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12691                 .channel_mode = alc268_modes,
12692                 .input_mux = &alc268_acer_capture_source,
12693                 .unsol_event = alc268_acer_unsol_event,
12694                 .init_hook = alc268_acer_init_hook,
12695         },
12696         [ALC268_ACER_DMIC] = {
12697                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
12698                             alc268_beep_mixer },
12699                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12700                                 alc268_acer_verbs },
12701                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12702                 .dac_nids = alc268_dac_nids,
12703                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12704                 .adc_nids = alc268_adc_nids_alt,
12705                 .capsrc_nids = alc268_capsrc_nids,
12706                 .hp_nid = 0x02,
12707                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12708                 .channel_mode = alc268_modes,
12709                 .input_mux = &alc268_acer_dmic_capture_source,
12710                 .unsol_event = alc268_acer_unsol_event,
12711                 .init_hook = alc268_acer_init_hook,
12712         },
12713         [ALC268_ACER_ASPIRE_ONE] = {
12714                 .mixers = { alc268_acer_aspire_one_mixer,
12715                             alc268_beep_mixer,
12716                             alc268_capture_nosrc_mixer },
12717                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12718                                 alc268_acer_aspire_one_verbs },
12719                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12720                 .dac_nids = alc268_dac_nids,
12721                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12722                 .adc_nids = alc268_adc_nids_alt,
12723                 .capsrc_nids = alc268_capsrc_nids,
12724                 .hp_nid = 0x03,
12725                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12726                 .channel_mode = alc268_modes,
12727                 .unsol_event = alc268_acer_lc_unsol_event,
12728                 .setup = alc268_acer_lc_setup,
12729                 .init_hook = alc268_acer_lc_init_hook,
12730         },
12731         [ALC268_DELL] = {
12732                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
12733                             alc268_capture_nosrc_mixer },
12734                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12735                                 alc268_dell_verbs },
12736                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12737                 .dac_nids = alc268_dac_nids,
12738                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12739                 .adc_nids = alc268_adc_nids_alt,
12740                 .capsrc_nids = alc268_capsrc_nids,
12741                 .hp_nid = 0x02,
12742                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12743                 .channel_mode = alc268_modes,
12744                 .unsol_event = alc_sku_unsol_event,
12745                 .setup = alc268_dell_setup,
12746                 .init_hook = alc_inithook,
12747         },
12748         [ALC268_ZEPTO] = {
12749                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
12750                             alc268_beep_mixer },
12751                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12752                                 alc268_toshiba_verbs },
12753                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12754                 .dac_nids = alc268_dac_nids,
12755                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12756                 .adc_nids = alc268_adc_nids_alt,
12757                 .capsrc_nids = alc268_capsrc_nids,
12758                 .hp_nid = 0x03,
12759                 .dig_out_nid = ALC268_DIGOUT_NID,
12760                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12761                 .channel_mode = alc268_modes,
12762                 .input_mux = &alc268_capture_source,
12763                 .setup = alc268_toshiba_setup,
12764                 .init_hook = alc268_toshiba_automute,
12765         },
12766 #ifdef CONFIG_SND_DEBUG
12767         [ALC268_TEST] = {
12768                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
12769                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
12770                                 alc268_volume_init_verbs },
12771                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
12772                 .dac_nids = alc268_dac_nids,
12773                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
12774                 .adc_nids = alc268_adc_nids_alt,
12775                 .capsrc_nids = alc268_capsrc_nids,
12776                 .hp_nid = 0x03,
12777                 .dig_out_nid = ALC268_DIGOUT_NID,
12778                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
12779                 .channel_mode = alc268_modes,
12780                 .input_mux = &alc268_capture_source,
12781         },
12782 #endif
12783 };
12784
12785 static int patch_alc268(struct hda_codec *codec)
12786 {
12787         struct alc_spec *spec;
12788         int board_config;
12789         int i, has_beep, err;
12790
12791         spec = kcalloc(1, sizeof(*spec), GFP_KERNEL);
12792         if (spec == NULL)
12793                 return -ENOMEM;
12794
12795         codec->spec = spec;
12796
12797         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
12798                                                   alc268_models,
12799                                                   alc268_cfg_tbl);
12800
12801         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
12802                 board_config = snd_hda_check_board_codec_sid_config(codec,
12803                         ALC882_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
12804
12805         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
12806                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12807                        codec->chip_name);
12808                 board_config = ALC268_AUTO;
12809         }
12810
12811         if (board_config == ALC268_AUTO) {
12812                 /* automatic parse from the BIOS config */
12813                 err = alc268_parse_auto_config(codec);
12814                 if (err < 0) {
12815                         alc_free(codec);
12816                         return err;
12817                 } else if (!err) {
12818                         printk(KERN_INFO
12819                                "hda_codec: Cannot set up configuration "
12820                                "from BIOS.  Using base mode...\n");
12821                         board_config = ALC268_3ST;
12822                 }
12823         }
12824
12825         if (board_config != ALC268_AUTO)
12826                 setup_preset(codec, &alc268_presets[board_config]);
12827
12828         spec->stream_analog_playback = &alc268_pcm_analog_playback;
12829         spec->stream_analog_capture = &alc268_pcm_analog_capture;
12830         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
12831
12832         spec->stream_digital_playback = &alc268_pcm_digital_playback;
12833
12834         has_beep = 0;
12835         for (i = 0; i < spec->num_mixers; i++) {
12836                 if (spec->mixers[i] == alc268_beep_mixer) {
12837                         has_beep = 1;
12838                         break;
12839                 }
12840         }
12841
12842         if (has_beep) {
12843                 err = snd_hda_attach_beep_device(codec, 0x1);
12844                 if (err < 0) {
12845                         alc_free(codec);
12846                         return err;
12847                 }
12848                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
12849                         /* override the amp caps for beep generator */
12850                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
12851                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
12852                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
12853                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
12854                                           (0 << AC_AMPCAP_MUTE_SHIFT));
12855         }
12856
12857         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
12858                 /* check whether NID 0x07 is valid */
12859                 unsigned int wcap = get_wcaps(codec, 0x07);
12860                 int i;
12861
12862                 spec->capsrc_nids = alc268_capsrc_nids;
12863                 /* get type */
12864                 wcap = get_wcaps_type(wcap);
12865                 if (spec->auto_mic ||
12866                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
12867                         spec->adc_nids = alc268_adc_nids_alt;
12868                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
12869                         if (spec->auto_mic)
12870                                 fixup_automic_adc(codec);
12871                         if (spec->auto_mic || spec->input_mux->num_items == 1)
12872                                 add_mixer(spec, alc268_capture_nosrc_mixer);
12873                         else
12874                                 add_mixer(spec, alc268_capture_alt_mixer);
12875                 } else {
12876                         spec->adc_nids = alc268_adc_nids;
12877                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
12878                         add_mixer(spec, alc268_capture_mixer);
12879                 }
12880                 /* set default input source */
12881                 for (i = 0; i < spec->num_adc_nids; i++)
12882                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
12883                                 0, AC_VERB_SET_CONNECT_SEL,
12884                                 i < spec->num_mux_defs ?
12885                                 spec->input_mux[i].items[0].index :
12886                                 spec->input_mux->items[0].index);
12887         }
12888
12889         spec->vmaster_nid = 0x02;
12890
12891         codec->patch_ops = alc_patch_ops;
12892         if (board_config == ALC268_AUTO)
12893                 spec->init_hook = alc268_auto_init;
12894
12895         codec->proc_widget_hook = print_realtek_coef;
12896
12897         return 0;
12898 }
12899
12900 /*
12901  *  ALC269 channel source setting (2 channel)
12902  */
12903 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
12904
12905 #define alc269_dac_nids         alc260_dac_nids
12906
12907 static hda_nid_t alc269_adc_nids[1] = {
12908         /* ADC1 */
12909         0x08,
12910 };
12911
12912 static hda_nid_t alc269_capsrc_nids[1] = {
12913         0x23,
12914 };
12915
12916 /* NOTE: ADC2 (0x07) is connected from a recording *MIXER* (0x24),
12917  *       not a mux!
12918  */
12919
12920 #define alc269_modes            alc260_modes
12921 #define alc269_capture_source   alc880_lg_lw_capture_source
12922
12923 static struct snd_kcontrol_new alc269_base_mixer[] = {
12924         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12925         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12926         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
12927         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
12928         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12929         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12930         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12931         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12932         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12933         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12934         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12935         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
12936         { } /* end */
12937 };
12938
12939 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
12940         /* output mixer control */
12941         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12942         {
12943                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12944                 .name = "Master Playback Switch",
12945                 .info = snd_hda_mixer_amp_switch_info,
12946                 .get = snd_hda_mixer_amp_switch_get,
12947                 .put = alc268_acer_master_sw_put,
12948                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12949         },
12950         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12951         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12952         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12953         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12954         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12955         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12956         { }
12957 };
12958
12959 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
12960         /* output mixer control */
12961         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12962         {
12963                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12964                 .name = "Master Playback Switch",
12965                 .info = snd_hda_mixer_amp_switch_info,
12966                 .get = snd_hda_mixer_amp_switch_get,
12967                 .put = alc268_acer_master_sw_put,
12968                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12969         },
12970         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
12971         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
12972         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12973         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
12974         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
12975         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12976         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
12977         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
12978         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
12979         { }
12980 };
12981
12982 static struct snd_kcontrol_new alc269_eeepc_mixer[] = {
12983         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12984         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12985         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12986         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12987         { } /* end */
12988 };
12989
12990 /* capture mixer elements */
12991 static struct snd_kcontrol_new alc269_epc_capture_mixer[] = {
12992         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
12993         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
12994         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12995         { } /* end */
12996 };
12997
12998 /* FSC amilo */
12999 #define alc269_fujitsu_mixer    alc269_eeepc_mixer
13000
13001 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13002         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13003         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13004         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13005         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13006         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13007         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13008         { }
13009 };
13010
13011 static struct hda_verb alc269_lifebook_verbs[] = {
13012         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13013         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13014         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13015         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13016         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13017         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13018         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13019         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13020         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13021         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13022         { }
13023 };
13024
13025 /* toggle speaker-output according to the hp-jack state */
13026 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13027 {
13028         unsigned int present;
13029         unsigned char bits;
13030
13031         present = snd_hda_codec_read(codec, 0x15, 0,
13032                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13033         bits = present ? AMP_IN_MUTE(0) : 0;
13034         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13035                         AMP_IN_MUTE(0), bits);
13036         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13037                         AMP_IN_MUTE(0), bits);
13038
13039         snd_hda_codec_write(codec, 0x20, 0,
13040                         AC_VERB_SET_COEF_INDEX, 0x0c);
13041         snd_hda_codec_write(codec, 0x20, 0,
13042                         AC_VERB_SET_PROC_COEF, 0x680);
13043
13044         snd_hda_codec_write(codec, 0x20, 0,
13045                         AC_VERB_SET_COEF_INDEX, 0x0c);
13046         snd_hda_codec_write(codec, 0x20, 0,
13047                         AC_VERB_SET_PROC_COEF, 0x480);
13048 }
13049
13050 /* toggle speaker-output according to the hp-jacks state */
13051 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13052 {
13053         unsigned int present;
13054         unsigned char bits;
13055
13056         /* Check laptop headphone socket */
13057         present = snd_hda_codec_read(codec, 0x15, 0,
13058                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13059
13060         /* Check port replicator headphone socket */
13061         present |= snd_hda_codec_read(codec, 0x1a, 0,
13062                         AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13063
13064         bits = present ? AMP_IN_MUTE(0) : 0;
13065         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13066                         AMP_IN_MUTE(0), bits);
13067         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13068                         AMP_IN_MUTE(0), bits);
13069
13070         snd_hda_codec_write(codec, 0x20, 0,
13071                         AC_VERB_SET_COEF_INDEX, 0x0c);
13072         snd_hda_codec_write(codec, 0x20, 0,
13073                         AC_VERB_SET_PROC_COEF, 0x680);
13074
13075         snd_hda_codec_write(codec, 0x20, 0,
13076                         AC_VERB_SET_COEF_INDEX, 0x0c);
13077         snd_hda_codec_write(codec, 0x20, 0,
13078                         AC_VERB_SET_PROC_COEF, 0x480);
13079 }
13080
13081 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13082 {
13083         unsigned int present_laptop;
13084         unsigned int present_dock;
13085
13086         present_laptop = snd_hda_codec_read(codec, 0x18, 0,
13087                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13088
13089         present_dock = snd_hda_codec_read(codec, 0x1b, 0,
13090                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13091
13092         /* Laptop mic port overrides dock mic port, design decision */
13093         if (present_dock)
13094                 snd_hda_codec_write(codec, 0x23, 0,
13095                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13096         if (present_laptop)
13097                 snd_hda_codec_write(codec, 0x23, 0,
13098                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13099         if (!present_dock && !present_laptop)
13100                 snd_hda_codec_write(codec, 0x23, 0,
13101                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13102 }
13103
13104 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13105                                     unsigned int res)
13106 {
13107         switch (res >> 26) {
13108         case ALC880_HP_EVENT:
13109                 alc269_quanta_fl1_speaker_automute(codec);
13110                 break;
13111         case ALC880_MIC_EVENT:
13112                 alc_mic_automute(codec);
13113                 break;
13114         }
13115 }
13116
13117 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13118                                         unsigned int res)
13119 {
13120         if ((res >> 26) == ALC880_HP_EVENT)
13121                 alc269_lifebook_speaker_automute(codec);
13122         if ((res >> 26) == ALC880_MIC_EVENT)
13123                 alc269_lifebook_mic_autoswitch(codec);
13124 }
13125
13126 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13127 {
13128         struct alc_spec *spec = codec->spec;
13129         spec->ext_mic.pin = 0x18;
13130         spec->ext_mic.mux_idx = 0;
13131         spec->int_mic.pin = 0x19;
13132         spec->int_mic.mux_idx = 1;
13133         spec->auto_mic = 1;
13134 }
13135
13136 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13137 {
13138         alc269_quanta_fl1_speaker_automute(codec);
13139         alc_mic_automute(codec);
13140 }
13141
13142 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13143 {
13144         alc269_lifebook_speaker_automute(codec);
13145         alc269_lifebook_mic_autoswitch(codec);
13146 }
13147
13148 static struct hda_verb alc269_eeepc_dmic_init_verbs[] = {
13149         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13150         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13151         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13152         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13153         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13154         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13155         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13156         {}
13157 };
13158
13159 static struct hda_verb alc269_eeepc_amic_init_verbs[] = {
13160         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13161         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13162         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13163         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13164         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13165         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13166         {}
13167 };
13168
13169 /* toggle speaker-output according to the hp-jack state */
13170 static void alc269_speaker_automute(struct hda_codec *codec)
13171 {
13172         unsigned int present;
13173         unsigned char bits;
13174
13175         present = snd_hda_codec_read(codec, 0x15, 0,
13176                                 AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
13177         bits = present ? AMP_IN_MUTE(0) : 0;
13178         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13179                                 AMP_IN_MUTE(0), bits);
13180         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13181                                 AMP_IN_MUTE(0), bits);
13182 }
13183
13184 /* unsolicited event for HP jack sensing */
13185 static void alc269_eeepc_unsol_event(struct hda_codec *codec,
13186                                      unsigned int res)
13187 {
13188         switch (res >> 26) {
13189         case ALC880_HP_EVENT:
13190                 alc269_speaker_automute(codec);
13191                 break;
13192         case ALC880_MIC_EVENT:
13193                 alc_mic_automute(codec);
13194                 break;
13195         }
13196 }
13197
13198 static void alc269_eeepc_dmic_setup(struct hda_codec *codec)
13199 {
13200         struct alc_spec *spec = codec->spec;
13201         spec->ext_mic.pin = 0x18;
13202         spec->ext_mic.mux_idx = 0;
13203         spec->int_mic.pin = 0x12;
13204         spec->int_mic.mux_idx = 5;
13205         spec->auto_mic = 1;
13206 }
13207
13208 static void alc269_eeepc_amic_setup(struct hda_codec *codec)
13209 {
13210         struct alc_spec *spec = codec->spec;
13211         spec->ext_mic.pin = 0x18;
13212         spec->ext_mic.mux_idx = 0;
13213         spec->int_mic.pin = 0x19;
13214         spec->int_mic.mux_idx = 1;
13215         spec->auto_mic = 1;
13216 }
13217
13218 static void alc269_eeepc_inithook(struct hda_codec *codec)
13219 {
13220         alc269_speaker_automute(codec);
13221         alc_mic_automute(codec);
13222 }
13223
13224 /*
13225  * generic initialization of ADC, input mixers and output mixers
13226  */
13227 static struct hda_verb alc269_init_verbs[] = {
13228         /*
13229          * Unmute ADC0 and set the default input to mic-in
13230          */
13231         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13232
13233         /* Mute input amps (PCBeep, Line In, Mic 1 & Mic 2) of the
13234          * analog-loopback mixer widget
13235          * Note: PASD motherboards uses the Line In 2 as the input for
13236          * front panel mic (mic 2)
13237          */
13238         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
13239         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13240         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
13241         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13242         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13243         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
13244
13245         /*
13246          * Set up output mixers (0x0c - 0x0e)
13247          */
13248         /* set vol=0 to output mixers */
13249         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13250         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13251
13252         /* set up input amps for analog loopback */
13253         /* Amp Indices: DAC = 0, mixer = 1 */
13254         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13255         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13256         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13257         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13258         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13259         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13260
13261         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13262         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13263         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13264         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13265         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13266         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13267         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13268
13269         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13270         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13271         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13272         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13273         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13274         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13275         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
13276
13277         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
13278         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
13279
13280         /* FIXME: use matrix-type input source selection */
13281         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13282         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13283         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
13284         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13285         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
13286         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
13287
13288         /* set EAPD */
13289         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13290         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
13291         { }
13292 };
13293
13294 #define alc269_auto_create_multi_out_ctls \
13295         alc268_auto_create_multi_out_ctls
13296 #define alc269_auto_create_input_ctls \
13297         alc268_auto_create_input_ctls
13298
13299 #ifdef CONFIG_SND_HDA_POWER_SAVE
13300 #define alc269_loopbacks        alc880_loopbacks
13301 #endif
13302
13303 /* pcm configuration: identical with ALC880 */
13304 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13305 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13306 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13307 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13308
13309 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13310         .substreams = 1,
13311         .channels_min = 2,
13312         .channels_max = 8,
13313         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13314         /* NID is set in alc_build_pcms */
13315         .ops = {
13316                 .open = alc880_playback_pcm_open,
13317                 .prepare = alc880_playback_pcm_prepare,
13318                 .cleanup = alc880_playback_pcm_cleanup
13319         },
13320 };
13321
13322 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13323         .substreams = 1,
13324         .channels_min = 2,
13325         .channels_max = 2,
13326         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13327         /* NID is set in alc_build_pcms */
13328 };
13329
13330 /*
13331  * BIOS auto configuration
13332  */
13333 static int alc269_parse_auto_config(struct hda_codec *codec)
13334 {
13335         struct alc_spec *spec = codec->spec;
13336         int err;
13337         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13338
13339         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13340                                            alc269_ignore);
13341         if (err < 0)
13342                 return err;
13343
13344         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13345         if (err < 0)
13346                 return err;
13347         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13348         if (err < 0)
13349                 return err;
13350
13351         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13352
13353         if (spec->autocfg.dig_outs)
13354                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13355
13356         if (spec->kctls.list)
13357                 add_mixer(spec, spec->kctls.list);
13358
13359         add_verb(spec, alc269_init_verbs);
13360         spec->num_mux_defs = 1;
13361         spec->input_mux = &spec->private_imux[0];
13362         /* set default input source */
13363         snd_hda_codec_write_cache(codec, alc269_capsrc_nids[0],
13364                                   0, AC_VERB_SET_CONNECT_SEL,
13365                                   spec->input_mux->items[0].index);
13366
13367         err = alc_auto_add_mic_boost(codec);
13368         if (err < 0)
13369                 return err;
13370
13371         if (!spec->cap_mixer && !spec->no_analog)
13372                 set_capture_mixer(codec);
13373
13374         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
13375
13376         return 1;
13377 }
13378
13379 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
13380 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
13381 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
13382
13383
13384 /* init callback for auto-configuration model -- overriding the default init */
13385 static void alc269_auto_init(struct hda_codec *codec)
13386 {
13387         struct alc_spec *spec = codec->spec;
13388         alc269_auto_init_multi_out(codec);
13389         alc269_auto_init_hp_out(codec);
13390         alc269_auto_init_analog_input(codec);
13391         if (spec->unsol_event)
13392                 alc_inithook(codec);
13393 }
13394
13395 /*
13396  * configuration and preset
13397  */
13398 static const char *alc269_models[ALC269_MODEL_LAST] = {
13399         [ALC269_BASIC]                  = "basic",
13400         [ALC269_QUANTA_FL1]             = "quanta",
13401         [ALC269_ASUS_EEEPC_P703]        = "eeepc-p703",
13402         [ALC269_ASUS_EEEPC_P901]        = "eeepc-p901",
13403         [ALC269_FUJITSU]                = "fujitsu",
13404         [ALC269_LIFEBOOK]               = "lifebook",
13405         [ALC269_AUTO]                   = "auto",
13406 };
13407
13408 static struct snd_pci_quirk alc269_cfg_tbl[] = {
13409         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
13410         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
13411                       ALC269_ASUS_EEEPC_P703),
13412         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_ASUS_EEEPC_P703),
13413         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_ASUS_EEEPC_P703),
13414         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_ASUS_EEEPC_P703),
13415         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_ASUS_EEEPC_P703),
13416         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_ASUS_EEEPC_P703),
13417         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_ASUS_EEEPC_P703),
13418         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
13419                       ALC269_ASUS_EEEPC_P901),
13420         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
13421                       ALC269_ASUS_EEEPC_P901),
13422         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_ASUS_EEEPC_P901),
13423         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
13424         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
13425         {}
13426 };
13427
13428 static struct alc_config_preset alc269_presets[] = {
13429         [ALC269_BASIC] = {
13430                 .mixers = { alc269_base_mixer },
13431                 .init_verbs = { alc269_init_verbs },
13432                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13433                 .dac_nids = alc269_dac_nids,
13434                 .hp_nid = 0x03,
13435                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13436                 .channel_mode = alc269_modes,
13437                 .input_mux = &alc269_capture_source,
13438         },
13439         [ALC269_QUANTA_FL1] = {
13440                 .mixers = { alc269_quanta_fl1_mixer },
13441                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
13442                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13443                 .dac_nids = alc269_dac_nids,
13444                 .hp_nid = 0x03,
13445                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13446                 .channel_mode = alc269_modes,
13447                 .input_mux = &alc269_capture_source,
13448                 .unsol_event = alc269_quanta_fl1_unsol_event,
13449                 .setup = alc269_quanta_fl1_setup,
13450                 .init_hook = alc269_quanta_fl1_init_hook,
13451         },
13452         [ALC269_ASUS_EEEPC_P703] = {
13453                 .mixers = { alc269_eeepc_mixer },
13454                 .cap_mixer = alc269_epc_capture_mixer,
13455                 .init_verbs = { alc269_init_verbs,
13456                                 alc269_eeepc_amic_init_verbs },
13457                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13458                 .dac_nids = alc269_dac_nids,
13459                 .hp_nid = 0x03,
13460                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13461                 .channel_mode = alc269_modes,
13462                 .unsol_event = alc269_eeepc_unsol_event,
13463                 .setup = alc269_eeepc_amic_setup,
13464                 .init_hook = alc269_eeepc_inithook,
13465         },
13466         [ALC269_ASUS_EEEPC_P901] = {
13467                 .mixers = { alc269_eeepc_mixer },
13468                 .cap_mixer = alc269_epc_capture_mixer,
13469                 .init_verbs = { alc269_init_verbs,
13470                                 alc269_eeepc_dmic_init_verbs },
13471                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13472                 .dac_nids = alc269_dac_nids,
13473                 .hp_nid = 0x03,
13474                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13475                 .channel_mode = alc269_modes,
13476                 .unsol_event = alc269_eeepc_unsol_event,
13477                 .setup = alc269_eeepc_dmic_setup,
13478                 .init_hook = alc269_eeepc_inithook,
13479         },
13480         [ALC269_FUJITSU] = {
13481                 .mixers = { alc269_fujitsu_mixer },
13482                 .cap_mixer = alc269_epc_capture_mixer,
13483                 .init_verbs = { alc269_init_verbs,
13484                                 alc269_eeepc_dmic_init_verbs },
13485                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13486                 .dac_nids = alc269_dac_nids,
13487                 .hp_nid = 0x03,
13488                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13489                 .channel_mode = alc269_modes,
13490                 .unsol_event = alc269_eeepc_unsol_event,
13491                 .setup = alc269_eeepc_dmic_setup,
13492                 .init_hook = alc269_eeepc_inithook,
13493         },
13494         [ALC269_LIFEBOOK] = {
13495                 .mixers = { alc269_lifebook_mixer },
13496                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
13497                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
13498                 .dac_nids = alc269_dac_nids,
13499                 .hp_nid = 0x03,
13500                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
13501                 .channel_mode = alc269_modes,
13502                 .input_mux = &alc269_capture_source,
13503                 .unsol_event = alc269_lifebook_unsol_event,
13504                 .init_hook = alc269_lifebook_init_hook,
13505         },
13506 };
13507
13508 static int patch_alc269(struct hda_codec *codec)
13509 {
13510         struct alc_spec *spec;
13511         int board_config;
13512         int err;
13513
13514         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13515         if (spec == NULL)
13516                 return -ENOMEM;
13517
13518         codec->spec = spec;
13519
13520         alc_fix_pll_init(codec, 0x20, 0x04, 15);
13521
13522         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
13523                                                   alc269_models,
13524                                                   alc269_cfg_tbl);
13525
13526         if (board_config < 0) {
13527                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13528                        codec->chip_name);
13529                 board_config = ALC269_AUTO;
13530         }
13531
13532         if (board_config == ALC269_AUTO) {
13533                 /* automatic parse from the BIOS config */
13534                 err = alc269_parse_auto_config(codec);
13535                 if (err < 0) {
13536                         alc_free(codec);
13537                         return err;
13538                 } else if (!err) {
13539                         printk(KERN_INFO
13540                                "hda_codec: Cannot set up configuration "
13541                                "from BIOS.  Using base mode...\n");
13542                         board_config = ALC269_BASIC;
13543                 }
13544         }
13545
13546         err = snd_hda_attach_beep_device(codec, 0x1);
13547         if (err < 0) {
13548                 alc_free(codec);
13549                 return err;
13550         }
13551
13552         if (board_config != ALC269_AUTO)
13553                 setup_preset(codec, &alc269_presets[board_config]);
13554
13555         if (codec->subsystem_id == 0x17aa3bf8) {
13556                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
13557                  * fix the sample rate of analog I/O to 44.1kHz
13558                  */
13559                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
13560                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
13561         } else {
13562                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
13563                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
13564         }
13565         spec->stream_digital_playback = &alc269_pcm_digital_playback;
13566         spec->stream_digital_capture = &alc269_pcm_digital_capture;
13567
13568         spec->adc_nids = alc269_adc_nids;
13569         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
13570         spec->capsrc_nids = alc269_capsrc_nids;
13571         if (!spec->cap_mixer)
13572                 set_capture_mixer(codec);
13573         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
13574
13575         spec->vmaster_nid = 0x02;
13576
13577         codec->patch_ops = alc_patch_ops;
13578         if (board_config == ALC269_AUTO)
13579                 spec->init_hook = alc269_auto_init;
13580 #ifdef CONFIG_SND_HDA_POWER_SAVE
13581         if (!spec->loopback.amplist)
13582                 spec->loopback.amplist = alc269_loopbacks;
13583 #endif
13584         codec->proc_widget_hook = print_realtek_coef;
13585
13586         return 0;
13587 }
13588
13589 /*
13590  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
13591  */
13592
13593 /*
13594  * set the path ways for 2 channel output
13595  * need to set the codec line out and mic 1 pin widgets to inputs
13596  */
13597 static struct hda_verb alc861_threestack_ch2_init[] = {
13598         /* set pin widget 1Ah (line in) for input */
13599         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13600         /* set pin widget 18h (mic1/2) for input, for mic also enable
13601          * the vref
13602          */
13603         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13604
13605         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13606 #if 0
13607         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13608         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13609 #endif
13610         { } /* end */
13611 };
13612 /*
13613  * 6ch mode
13614  * need to set the codec line out and mic 1 pin widgets to outputs
13615  */
13616 static struct hda_verb alc861_threestack_ch6_init[] = {
13617         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13618         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13619         /* set pin widget 18h (mic1) for output (CLFE)*/
13620         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13621
13622         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13623         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13624
13625         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13626 #if 0
13627         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13628         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13629 #endif
13630         { } /* end */
13631 };
13632
13633 static struct hda_channel_mode alc861_threestack_modes[2] = {
13634         { 2, alc861_threestack_ch2_init },
13635         { 6, alc861_threestack_ch6_init },
13636 };
13637 /* Set mic1 as input and unmute the mixer */
13638 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
13639         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13640         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13641         { } /* end */
13642 };
13643 /* Set mic1 as output and mute mixer */
13644 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
13645         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13646         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13647         { } /* end */
13648 };
13649
13650 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
13651         { 2, alc861_uniwill_m31_ch2_init },
13652         { 4, alc861_uniwill_m31_ch4_init },
13653 };
13654
13655 /* Set mic1 and line-in as input and unmute the mixer */
13656 static struct hda_verb alc861_asus_ch2_init[] = {
13657         /* set pin widget 1Ah (line in) for input */
13658         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13659         /* set pin widget 18h (mic1/2) for input, for mic also enable
13660          * the vref
13661          */
13662         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13663
13664         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
13665 #if 0
13666         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
13667         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
13668 #endif
13669         { } /* end */
13670 };
13671 /* Set mic1 nad line-in as output and mute mixer */
13672 static struct hda_verb alc861_asus_ch6_init[] = {
13673         /* set pin widget 1Ah (line in) for output (Back Surround)*/
13674         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13675         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13676         /* set pin widget 18h (mic1) for output (CLFE)*/
13677         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13678         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
13679         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
13680         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
13681
13682         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
13683 #if 0
13684         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
13685         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
13686 #endif
13687         { } /* end */
13688 };
13689
13690 static struct hda_channel_mode alc861_asus_modes[2] = {
13691         { 2, alc861_asus_ch2_init },
13692         { 6, alc861_asus_ch6_init },
13693 };
13694
13695 /* patch-ALC861 */
13696
13697 static struct snd_kcontrol_new alc861_base_mixer[] = {
13698         /* output mixer control */
13699         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13700         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13701         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13702         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13703         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13704
13705         /*Input mixer control */
13706         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13707            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13708         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13709         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13710         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13711         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13712         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13713         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13714         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13715         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13716
13717         { } /* end */
13718 };
13719
13720 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
13721         /* output mixer control */
13722         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13723         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13724         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13725         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13726         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13727
13728         /* Input mixer control */
13729         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13730            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13731         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13732         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13733         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13734         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13735         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13736         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13737         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13738         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13739
13740         {
13741                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13742                 .name = "Channel Mode",
13743                 .info = alc_ch_mode_info,
13744                 .get = alc_ch_mode_get,
13745                 .put = alc_ch_mode_put,
13746                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
13747         },
13748         { } /* end */
13749 };
13750
13751 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
13752         /* output mixer control */
13753         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13754         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13755         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13756
13757         { } /* end */
13758 };
13759
13760 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
13761         /* output mixer control */
13762         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13763         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13764         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13765         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13766         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
13767
13768         /* Input mixer control */
13769         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13770            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
13771         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13772         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13773         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13774         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13775         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13776         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13777         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13778         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
13779
13780         {
13781                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13782                 .name = "Channel Mode",
13783                 .info = alc_ch_mode_info,
13784                 .get = alc_ch_mode_get,
13785                 .put = alc_ch_mode_put,
13786                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
13787         },
13788         { } /* end */
13789 };
13790
13791 static struct snd_kcontrol_new alc861_asus_mixer[] = {
13792         /* output mixer control */
13793         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
13794         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
13795         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
13796         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
13797         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
13798
13799         /* Input mixer control */
13800         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
13801         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13802         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13803         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13804         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
13805         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
13806         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
13807         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
13808         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
13809         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
13810
13811         {
13812                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13813                 .name = "Channel Mode",
13814                 .info = alc_ch_mode_info,
13815                 .get = alc_ch_mode_get,
13816                 .put = alc_ch_mode_put,
13817                 .private_value = ARRAY_SIZE(alc861_asus_modes),
13818         },
13819         { }
13820 };
13821
13822 /* additional mixer */
13823 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
13824         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
13825         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
13826         { }
13827 };
13828
13829 /*
13830  * generic initialization of ADC, input mixers and output mixers
13831  */
13832 static struct hda_verb alc861_base_init_verbs[] = {
13833         /*
13834          * Unmute ADC0 and set the default input to mic-in
13835          */
13836         /* port-A for surround (rear panel) */
13837         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13838         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
13839         /* port-B for mic-in (rear panel) with vref */
13840         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13841         /* port-C for line-in (rear panel) */
13842         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13843         /* port-D for Front */
13844         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13845         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13846         /* port-E for HP out (front panel) */
13847         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13848         /* route front PCM to HP */
13849         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13850         /* port-F for mic-in (front panel) with vref */
13851         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13852         /* port-G for CLFE (rear panel) */
13853         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13854         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13855         /* port-H for side (rear panel) */
13856         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13857         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
13858         /* CD-in */
13859         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13860         /* route front mic to ADC1*/
13861         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13862         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13863
13864         /* Unmute DAC0~3 & spdif out*/
13865         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13866         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13867         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13868         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13869         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13870
13871         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13872         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13873         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13874         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13875         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13876
13877         /* Unmute Stereo Mixer 15 */
13878         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13879         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13880         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13881         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13882
13883         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13884         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13885         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13886         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13887         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13888         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13889         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13890         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13891         /* hp used DAC 3 (Front) */
13892         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13893         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13894
13895         { }
13896 };
13897
13898 static struct hda_verb alc861_threestack_init_verbs[] = {
13899         /*
13900          * Unmute ADC0 and set the default input to mic-in
13901          */
13902         /* port-A for surround (rear panel) */
13903         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13904         /* port-B for mic-in (rear panel) with vref */
13905         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13906         /* port-C for line-in (rear panel) */
13907         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13908         /* port-D for Front */
13909         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13910         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13911         /* port-E for HP out (front panel) */
13912         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
13913         /* route front PCM to HP */
13914         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13915         /* port-F for mic-in (front panel) with vref */
13916         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13917         /* port-G for CLFE (rear panel) */
13918         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13919         /* port-H for side (rear panel) */
13920         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13921         /* CD-in */
13922         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13923         /* route front mic to ADC1*/
13924         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13925         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13926         /* Unmute DAC0~3 & spdif out*/
13927         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13928         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13929         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13930         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13931         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13932
13933         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13934         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13935         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13936         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13937         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13938
13939         /* Unmute Stereo Mixer 15 */
13940         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13941         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13942         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13943         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
13944
13945         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13946         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13947         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13948         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13949         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13950         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13951         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13952         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13953         /* hp used DAC 3 (Front) */
13954         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
13955         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
13956         { }
13957 };
13958
13959 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
13960         /*
13961          * Unmute ADC0 and set the default input to mic-in
13962          */
13963         /* port-A for surround (rear panel) */
13964         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13965         /* port-B for mic-in (rear panel) with vref */
13966         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13967         /* port-C for line-in (rear panel) */
13968         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13969         /* port-D for Front */
13970         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
13971         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
13972         /* port-E for HP out (front panel) */
13973         /* this has to be set to VREF80 */
13974         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13975         /* route front PCM to HP */
13976         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
13977         /* port-F for mic-in (front panel) with vref */
13978         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
13979         /* port-G for CLFE (rear panel) */
13980         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13981         /* port-H for side (rear panel) */
13982         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
13983         /* CD-in */
13984         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
13985         /* route front mic to ADC1*/
13986         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
13987         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13988         /* Unmute DAC0~3 & spdif out*/
13989         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13990         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13991         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13992         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13993         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13994
13995         /* Unmute Mixer 14 (mic) 1c (Line in)*/
13996         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13997         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13998         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13999         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14000
14001         /* Unmute Stereo Mixer 15 */
14002         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14003         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14004         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14005         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14006
14007         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14008         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14009         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14010         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14011         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14012         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14013         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14014         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14015         /* hp used DAC 3 (Front) */
14016         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14017         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14018         { }
14019 };
14020
14021 static struct hda_verb alc861_asus_init_verbs[] = {
14022         /*
14023          * Unmute ADC0 and set the default input to mic-in
14024          */
14025         /* port-A for surround (rear panel)
14026          * according to codec#0 this is the HP jack
14027          */
14028         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14029         /* route front PCM to HP */
14030         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14031         /* port-B for mic-in (rear panel) with vref */
14032         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14033         /* port-C for line-in (rear panel) */
14034         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14035         /* port-D for Front */
14036         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14037         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14038         /* port-E for HP out (front panel) */
14039         /* this has to be set to VREF80 */
14040         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14041         /* route front PCM to HP */
14042         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14043         /* port-F for mic-in (front panel) with vref */
14044         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14045         /* port-G for CLFE (rear panel) */
14046         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14047         /* port-H for side (rear panel) */
14048         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14049         /* CD-in */
14050         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14051         /* route front mic to ADC1*/
14052         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14053         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14054         /* Unmute DAC0~3 & spdif out*/
14055         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14056         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14057         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14058         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14059         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14060         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14061         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14062         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14063         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14064         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14065
14066         /* Unmute Stereo Mixer 15 */
14067         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14068         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14069         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14070         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14071
14072         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14073         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14074         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14075         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14076         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14077         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14078         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14079         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14080         /* hp used DAC 3 (Front) */
14081         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14082         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14083         { }
14084 };
14085
14086 /* additional init verbs for ASUS laptops */
14087 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14088         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14089         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14090         { }
14091 };
14092
14093 /*
14094  * generic initialization of ADC, input mixers and output mixers
14095  */
14096 static struct hda_verb alc861_auto_init_verbs[] = {
14097         /*
14098          * Unmute ADC0 and set the default input to mic-in
14099          */
14100         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14101         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14102
14103         /* Unmute DAC0~3 & spdif out*/
14104         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14105         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14106         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14107         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14108         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14109
14110         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14111         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14112         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14113         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14114         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14115
14116         /* Unmute Stereo Mixer 15 */
14117         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14118         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14119         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14120         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14121
14122         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14123         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14124         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14125         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14126         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14127         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14128         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14129         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14130
14131         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14132         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14133         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14134         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14135         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14136         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14137         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14138         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14139
14140         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14141
14142         { }
14143 };
14144
14145 static struct hda_verb alc861_toshiba_init_verbs[] = {
14146         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14147
14148         { }
14149 };
14150
14151 /* toggle speaker-output according to the hp-jack state */
14152 static void alc861_toshiba_automute(struct hda_codec *codec)
14153 {
14154         unsigned int present;
14155
14156         present = snd_hda_codec_read(codec, 0x0f, 0,
14157                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
14158         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14159                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14160         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14161                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14162 }
14163
14164 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14165                                        unsigned int res)
14166 {
14167         if ((res >> 26) == ALC880_HP_EVENT)
14168                 alc861_toshiba_automute(codec);
14169 }
14170
14171 /* pcm configuration: identical with ALC880 */
14172 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14173 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14174 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14175 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14176
14177
14178 #define ALC861_DIGOUT_NID       0x07
14179
14180 static struct hda_channel_mode alc861_8ch_modes[1] = {
14181         { 8, NULL }
14182 };
14183
14184 static hda_nid_t alc861_dac_nids[4] = {
14185         /* front, surround, clfe, side */
14186         0x03, 0x06, 0x05, 0x04
14187 };
14188
14189 static hda_nid_t alc660_dac_nids[3] = {
14190         /* front, clfe, surround */
14191         0x03, 0x05, 0x06
14192 };
14193
14194 static hda_nid_t alc861_adc_nids[1] = {
14195         /* ADC0-2 */
14196         0x08,
14197 };
14198
14199 static struct hda_input_mux alc861_capture_source = {
14200         .num_items = 5,
14201         .items = {
14202                 { "Mic", 0x0 },
14203                 { "Front Mic", 0x3 },
14204                 { "Line", 0x1 },
14205                 { "CD", 0x4 },
14206                 { "Mixer", 0x5 },
14207         },
14208 };
14209
14210 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14211 {
14212         struct alc_spec *spec = codec->spec;
14213         hda_nid_t mix, srcs[5];
14214         int i, j, num;
14215
14216         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14217                 return 0;
14218         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14219         if (num < 0)
14220                 return 0;
14221         for (i = 0; i < num; i++) {
14222                 unsigned int type;
14223                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14224                 if (type != AC_WID_AUD_OUT)
14225                         continue;
14226                 for (j = 0; j < spec->multiout.num_dacs; j++)
14227                         if (spec->multiout.dac_nids[j] == srcs[i])
14228                                 break;
14229                 if (j >= spec->multiout.num_dacs)
14230                         return srcs[i];
14231         }
14232         return 0;
14233 }
14234
14235 /* fill in the dac_nids table from the parsed pin configuration */
14236 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14237                                      const struct auto_pin_cfg *cfg)
14238 {
14239         struct alc_spec *spec = codec->spec;
14240         int i;
14241         hda_nid_t nid, dac;
14242
14243         spec->multiout.dac_nids = spec->private_dac_nids;
14244         for (i = 0; i < cfg->line_outs; i++) {
14245                 nid = cfg->line_out_pins[i];
14246                 dac = alc861_look_for_dac(codec, nid);
14247                 if (!dac)
14248                         continue;
14249                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14250         }
14251         return 0;
14252 }
14253
14254 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14255                                 hda_nid_t nid, unsigned int chs)
14256 {
14257         char name[32];
14258         snprintf(name, sizeof(name), "%s Playback Switch", pfx);
14259         return add_control(codec->spec, ALC_CTL_WIDGET_MUTE, name,
14260                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14261 }
14262
14263 /* add playback controls from the parsed DAC table */
14264 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14265                                              const struct auto_pin_cfg *cfg)
14266 {
14267         struct alc_spec *spec = codec->spec;
14268         static const char *chname[4] = {
14269                 "Front", "Surround", NULL /*CLFE*/, "Side"
14270         };
14271         hda_nid_t nid;
14272         int i, err;
14273
14274         if (cfg->line_outs == 1) {
14275                 const char *pfx = NULL;
14276                 if (!cfg->hp_outs)
14277                         pfx = "Master";
14278                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
14279                         pfx = "Speaker";
14280                 if (pfx) {
14281                         nid = spec->multiout.dac_nids[0];
14282                         return alc861_create_out_sw(codec, pfx, nid, 3);
14283                 }
14284         }
14285
14286         for (i = 0; i < cfg->line_outs; i++) {
14287                 nid = spec->multiout.dac_nids[i];
14288                 if (!nid)
14289                         continue;
14290                 if (i == 2) {
14291                         /* Center/LFE */
14292                         err = alc861_create_out_sw(codec, "Center", nid, 1);
14293                         if (err < 0)
14294                                 return err;
14295                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
14296                         if (err < 0)
14297                                 return err;
14298                 } else {
14299                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
14300                         if (err < 0)
14301                                 return err;
14302                 }
14303         }
14304         return 0;
14305 }
14306
14307 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
14308 {
14309         struct alc_spec *spec = codec->spec;
14310         int err;
14311         hda_nid_t nid;
14312
14313         if (!pin)
14314                 return 0;
14315
14316         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
14317                 nid = alc861_look_for_dac(codec, pin);
14318                 if (nid) {
14319                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
14320                         if (err < 0)
14321                                 return err;
14322                         spec->multiout.hp_nid = nid;
14323                 }
14324         }
14325         return 0;
14326 }
14327
14328 /* create playback/capture controls for input pins */
14329 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
14330                                                 const struct auto_pin_cfg *cfg)
14331 {
14332         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
14333 }
14334
14335 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
14336                                               hda_nid_t nid,
14337                                               int pin_type, hda_nid_t dac)
14338 {
14339         hda_nid_t mix, srcs[5];
14340         int i, num;
14341
14342         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
14343                             pin_type);
14344         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14345                             AMP_OUT_UNMUTE);
14346         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
14347                 return;
14348         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14349         if (num < 0)
14350                 return;
14351         for (i = 0; i < num; i++) {
14352                 unsigned int mute;
14353                 if (srcs[i] == dac || srcs[i] == 0x15)
14354                         mute = AMP_IN_UNMUTE(i);
14355                 else
14356                         mute = AMP_IN_MUTE(i);
14357                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
14358                                     mute);
14359         }
14360 }
14361
14362 static void alc861_auto_init_multi_out(struct hda_codec *codec)
14363 {
14364         struct alc_spec *spec = codec->spec;
14365         int i;
14366
14367         for (i = 0; i < spec->autocfg.line_outs; i++) {
14368                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
14369                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
14370                 if (nid)
14371                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
14372                                                           spec->multiout.dac_nids[i]);
14373         }
14374 }
14375
14376 static void alc861_auto_init_hp_out(struct hda_codec *codec)
14377 {
14378         struct alc_spec *spec = codec->spec;
14379
14380         if (spec->autocfg.hp_outs)
14381                 alc861_auto_set_output_and_unmute(codec,
14382                                                   spec->autocfg.hp_pins[0],
14383                                                   PIN_HP,
14384                                                   spec->multiout.hp_nid);
14385         if (spec->autocfg.speaker_outs)
14386                 alc861_auto_set_output_and_unmute(codec,
14387                                                   spec->autocfg.speaker_pins[0],
14388                                                   PIN_OUT,
14389                                                   spec->multiout.dac_nids[0]);
14390 }
14391
14392 static void alc861_auto_init_analog_input(struct hda_codec *codec)
14393 {
14394         struct alc_spec *spec = codec->spec;
14395         int i;
14396
14397         for (i = 0; i < AUTO_PIN_LAST; i++) {
14398                 hda_nid_t nid = spec->autocfg.input_pins[i];
14399                 if (nid >= 0x0c && nid <= 0x11)
14400                         alc_set_input_pin(codec, nid, i);
14401         }
14402 }
14403
14404 /* parse the BIOS configuration and set up the alc_spec */
14405 /* return 1 if successful, 0 if the proper config is not found,
14406  * or a negative error code
14407  */
14408 static int alc861_parse_auto_config(struct hda_codec *codec)
14409 {
14410         struct alc_spec *spec = codec->spec;
14411         int err;
14412         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
14413
14414         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
14415                                            alc861_ignore);
14416         if (err < 0)
14417                 return err;
14418         if (!spec->autocfg.line_outs)
14419                 return 0; /* can't find valid BIOS pin config */
14420
14421         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
14422         if (err < 0)
14423                 return err;
14424         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
14425         if (err < 0)
14426                 return err;
14427         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
14428         if (err < 0)
14429                 return err;
14430         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
14431         if (err < 0)
14432                 return err;
14433
14434         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
14435
14436         if (spec->autocfg.dig_outs)
14437                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
14438
14439         if (spec->kctls.list)
14440                 add_mixer(spec, spec->kctls.list);
14441
14442         add_verb(spec, alc861_auto_init_verbs);
14443
14444         spec->num_mux_defs = 1;
14445         spec->input_mux = &spec->private_imux[0];
14446
14447         spec->adc_nids = alc861_adc_nids;
14448         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
14449         set_capture_mixer(codec);
14450
14451         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b);
14452
14453         return 1;
14454 }
14455
14456 /* additional initialization for auto-configuration model */
14457 static void alc861_auto_init(struct hda_codec *codec)
14458 {
14459         struct alc_spec *spec = codec->spec;
14460         alc861_auto_init_multi_out(codec);
14461         alc861_auto_init_hp_out(codec);
14462         alc861_auto_init_analog_input(codec);
14463         if (spec->unsol_event)
14464                 alc_inithook(codec);
14465 }
14466
14467 #ifdef CONFIG_SND_HDA_POWER_SAVE
14468 static struct hda_amp_list alc861_loopbacks[] = {
14469         { 0x15, HDA_INPUT, 0 },
14470         { 0x15, HDA_INPUT, 1 },
14471         { 0x15, HDA_INPUT, 2 },
14472         { 0x15, HDA_INPUT, 3 },
14473         { } /* end */
14474 };
14475 #endif
14476
14477
14478 /*
14479  * configuration and preset
14480  */
14481 static const char *alc861_models[ALC861_MODEL_LAST] = {
14482         [ALC861_3ST]            = "3stack",
14483         [ALC660_3ST]            = "3stack-660",
14484         [ALC861_3ST_DIG]        = "3stack-dig",
14485         [ALC861_6ST_DIG]        = "6stack-dig",
14486         [ALC861_UNIWILL_M31]    = "uniwill-m31",
14487         [ALC861_TOSHIBA]        = "toshiba",
14488         [ALC861_ASUS]           = "asus",
14489         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
14490         [ALC861_AUTO]           = "auto",
14491 };
14492
14493 static struct snd_pci_quirk alc861_cfg_tbl[] = {
14494         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
14495         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14496         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
14497         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
14498         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
14499         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
14500         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
14501         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
14502          *        Any other models that need this preset?
14503          */
14504         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
14505         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
14506         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
14507         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
14508         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
14509         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
14510         /* FIXME: the below seems conflict */
14511         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
14512         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
14513         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
14514         {}
14515 };
14516
14517 static struct alc_config_preset alc861_presets[] = {
14518         [ALC861_3ST] = {
14519                 .mixers = { alc861_3ST_mixer },
14520                 .init_verbs = { alc861_threestack_init_verbs },
14521                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14522                 .dac_nids = alc861_dac_nids,
14523                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14524                 .channel_mode = alc861_threestack_modes,
14525                 .need_dac_fix = 1,
14526                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14527                 .adc_nids = alc861_adc_nids,
14528                 .input_mux = &alc861_capture_source,
14529         },
14530         [ALC861_3ST_DIG] = {
14531                 .mixers = { alc861_base_mixer },
14532                 .init_verbs = { alc861_threestack_init_verbs },
14533                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14534                 .dac_nids = alc861_dac_nids,
14535                 .dig_out_nid = ALC861_DIGOUT_NID,
14536                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14537                 .channel_mode = alc861_threestack_modes,
14538                 .need_dac_fix = 1,
14539                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14540                 .adc_nids = alc861_adc_nids,
14541                 .input_mux = &alc861_capture_source,
14542         },
14543         [ALC861_6ST_DIG] = {
14544                 .mixers = { alc861_base_mixer },
14545                 .init_verbs = { alc861_base_init_verbs },
14546                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14547                 .dac_nids = alc861_dac_nids,
14548                 .dig_out_nid = ALC861_DIGOUT_NID,
14549                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
14550                 .channel_mode = alc861_8ch_modes,
14551                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14552                 .adc_nids = alc861_adc_nids,
14553                 .input_mux = &alc861_capture_source,
14554         },
14555         [ALC660_3ST] = {
14556                 .mixers = { alc861_3ST_mixer },
14557                 .init_verbs = { alc861_threestack_init_verbs },
14558                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
14559                 .dac_nids = alc660_dac_nids,
14560                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
14561                 .channel_mode = alc861_threestack_modes,
14562                 .need_dac_fix = 1,
14563                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14564                 .adc_nids = alc861_adc_nids,
14565                 .input_mux = &alc861_capture_source,
14566         },
14567         [ALC861_UNIWILL_M31] = {
14568                 .mixers = { alc861_uniwill_m31_mixer },
14569                 .init_verbs = { alc861_uniwill_m31_init_verbs },
14570                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14571                 .dac_nids = alc861_dac_nids,
14572                 .dig_out_nid = ALC861_DIGOUT_NID,
14573                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
14574                 .channel_mode = alc861_uniwill_m31_modes,
14575                 .need_dac_fix = 1,
14576                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14577                 .adc_nids = alc861_adc_nids,
14578                 .input_mux = &alc861_capture_source,
14579         },
14580         [ALC861_TOSHIBA] = {
14581                 .mixers = { alc861_toshiba_mixer },
14582                 .init_verbs = { alc861_base_init_verbs,
14583                                 alc861_toshiba_init_verbs },
14584                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14585                 .dac_nids = alc861_dac_nids,
14586                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14587                 .channel_mode = alc883_3ST_2ch_modes,
14588                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14589                 .adc_nids = alc861_adc_nids,
14590                 .input_mux = &alc861_capture_source,
14591                 .unsol_event = alc861_toshiba_unsol_event,
14592                 .init_hook = alc861_toshiba_automute,
14593         },
14594         [ALC861_ASUS] = {
14595                 .mixers = { alc861_asus_mixer },
14596                 .init_verbs = { alc861_asus_init_verbs },
14597                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14598                 .dac_nids = alc861_dac_nids,
14599                 .dig_out_nid = ALC861_DIGOUT_NID,
14600                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
14601                 .channel_mode = alc861_asus_modes,
14602                 .need_dac_fix = 1,
14603                 .hp_nid = 0x06,
14604                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14605                 .adc_nids = alc861_adc_nids,
14606                 .input_mux = &alc861_capture_source,
14607         },
14608         [ALC861_ASUS_LAPTOP] = {
14609                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
14610                 .init_verbs = { alc861_asus_init_verbs,
14611                                 alc861_asus_laptop_init_verbs },
14612                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
14613                 .dac_nids = alc861_dac_nids,
14614                 .dig_out_nid = ALC861_DIGOUT_NID,
14615                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
14616                 .channel_mode = alc883_3ST_2ch_modes,
14617                 .need_dac_fix = 1,
14618                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
14619                 .adc_nids = alc861_adc_nids,
14620                 .input_mux = &alc861_capture_source,
14621         },
14622 };
14623
14624
14625 static int patch_alc861(struct hda_codec *codec)
14626 {
14627         struct alc_spec *spec;
14628         int board_config;
14629         int err;
14630
14631         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14632         if (spec == NULL)
14633                 return -ENOMEM;
14634
14635         codec->spec = spec;
14636
14637         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
14638                                                   alc861_models,
14639                                                   alc861_cfg_tbl);
14640
14641         if (board_config < 0) {
14642                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14643                        codec->chip_name);
14644                 board_config = ALC861_AUTO;
14645         }
14646
14647         if (board_config == ALC861_AUTO) {
14648                 /* automatic parse from the BIOS config */
14649                 err = alc861_parse_auto_config(codec);
14650                 if (err < 0) {
14651                         alc_free(codec);
14652                         return err;
14653                 } else if (!err) {
14654                         printk(KERN_INFO
14655                                "hda_codec: Cannot set up configuration "
14656                                "from BIOS.  Using base mode...\n");
14657                    board_config = ALC861_3ST_DIG;
14658                 }
14659         }
14660
14661         err = snd_hda_attach_beep_device(codec, 0x23);
14662         if (err < 0) {
14663                 alc_free(codec);
14664                 return err;
14665         }
14666
14667         if (board_config != ALC861_AUTO)
14668                 setup_preset(codec, &alc861_presets[board_config]);
14669
14670         spec->stream_analog_playback = &alc861_pcm_analog_playback;
14671         spec->stream_analog_capture = &alc861_pcm_analog_capture;
14672
14673         spec->stream_digital_playback = &alc861_pcm_digital_playback;
14674         spec->stream_digital_capture = &alc861_pcm_digital_capture;
14675
14676         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
14677
14678         spec->vmaster_nid = 0x03;
14679
14680         codec->patch_ops = alc_patch_ops;
14681         if (board_config == ALC861_AUTO)
14682                 spec->init_hook = alc861_auto_init;
14683 #ifdef CONFIG_SND_HDA_POWER_SAVE
14684         if (!spec->loopback.amplist)
14685                 spec->loopback.amplist = alc861_loopbacks;
14686 #endif
14687         codec->proc_widget_hook = print_realtek_coef;
14688
14689         return 0;
14690 }
14691
14692 /*
14693  * ALC861-VD support
14694  *
14695  * Based on ALC882
14696  *
14697  * In addition, an independent DAC
14698  */
14699 #define ALC861VD_DIGOUT_NID     0x06
14700
14701 static hda_nid_t alc861vd_dac_nids[4] = {
14702         /* front, surr, clfe, side surr */
14703         0x02, 0x03, 0x04, 0x05
14704 };
14705
14706 /* dac_nids for ALC660vd are in a different order - according to
14707  * Realtek's driver.
14708  * This should probably result in a different mixer for 6stack models
14709  * of ALC660vd codecs, but for now there is only 3stack mixer
14710  * - and it is the same as in 861vd.
14711  * adc_nids in ALC660vd are (is) the same as in 861vd
14712  */
14713 static hda_nid_t alc660vd_dac_nids[3] = {
14714         /* front, rear, clfe, rear_surr */
14715         0x02, 0x04, 0x03
14716 };
14717
14718 static hda_nid_t alc861vd_adc_nids[1] = {
14719         /* ADC0 */
14720         0x09,
14721 };
14722
14723 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
14724
14725 /* input MUX */
14726 /* FIXME: should be a matrix-type input source selection */
14727 static struct hda_input_mux alc861vd_capture_source = {
14728         .num_items = 4,
14729         .items = {
14730                 { "Mic", 0x0 },
14731                 { "Front Mic", 0x1 },
14732                 { "Line", 0x2 },
14733                 { "CD", 0x4 },
14734         },
14735 };
14736
14737 static struct hda_input_mux alc861vd_dallas_capture_source = {
14738         .num_items = 2,
14739         .items = {
14740                 { "Ext Mic", 0x0 },
14741                 { "Int Mic", 0x1 },
14742         },
14743 };
14744
14745 static struct hda_input_mux alc861vd_hp_capture_source = {
14746         .num_items = 2,
14747         .items = {
14748                 { "Front Mic", 0x0 },
14749                 { "ATAPI Mic", 0x1 },
14750         },
14751 };
14752
14753 /*
14754  * 2ch mode
14755  */
14756 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
14757         { 2, NULL }
14758 };
14759
14760 /*
14761  * 6ch mode
14762  */
14763 static struct hda_verb alc861vd_6stack_ch6_init[] = {
14764         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14765         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14766         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14767         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14768         { } /* end */
14769 };
14770
14771 /*
14772  * 8ch mode
14773  */
14774 static struct hda_verb alc861vd_6stack_ch8_init[] = {
14775         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14776         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14777         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14778         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
14779         { } /* end */
14780 };
14781
14782 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
14783         { 6, alc861vd_6stack_ch6_init },
14784         { 8, alc861vd_6stack_ch8_init },
14785 };
14786
14787 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
14788         {
14789                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14790                 .name = "Channel Mode",
14791                 .info = alc_ch_mode_info,
14792                 .get = alc_ch_mode_get,
14793                 .put = alc_ch_mode_put,
14794         },
14795         { } /* end */
14796 };
14797
14798 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
14799  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
14800  */
14801 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
14802         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14803         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14804
14805         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14806         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
14807
14808         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
14809                                 HDA_OUTPUT),
14810         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
14811                                 HDA_OUTPUT),
14812         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
14813         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
14814
14815         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
14816         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
14817
14818         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14819
14820         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14821         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14822         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14823
14824         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14825         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14826         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14827
14828         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14829         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14830
14831         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14832         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14833
14834         { } /* end */
14835 };
14836
14837 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
14838         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14839         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14840
14841         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14842
14843         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14844         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14845         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14846
14847         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14848         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14849         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14850
14851         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
14852         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
14853
14854         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14855         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14856
14857         { } /* end */
14858 };
14859
14860 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
14861         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14862         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
14863         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
14864
14865         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
14866
14867         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
14868         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14869         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14870
14871         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
14872         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14873         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14874
14875         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
14876         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
14877
14878         { } /* end */
14879 };
14880
14881 /* Pin assignment: Speaker=0x14, HP = 0x15,
14882  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
14883  */
14884 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
14885         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14886         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
14887         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14888         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14889         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
14890         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14891         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14892         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
14893         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14894         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14895         { } /* end */
14896 };
14897
14898 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
14899  *                 Front Mic=0x18, ATAPI Mic = 0x19,
14900  */
14901 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
14902         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
14903         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
14904         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
14905         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
14906         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
14907         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
14908         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
14909         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
14910
14911         { } /* end */
14912 };
14913
14914 /*
14915  * generic initialization of ADC, input mixers and output mixers
14916  */
14917 static struct hda_verb alc861vd_volume_init_verbs[] = {
14918         /*
14919          * Unmute ADC0 and set the default input to mic-in
14920          */
14921         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
14922         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14923
14924         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
14925          * the analog-loopback mixer widget
14926          */
14927         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
14928         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14929         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14930         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14931         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14932         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
14933
14934         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
14935         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14936         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14937         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14938         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
14939
14940         /*
14941          * Set up output mixers (0x02 - 0x05)
14942          */
14943         /* set vol=0 to output mixers */
14944         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14945         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14946         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14947         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
14948
14949         /* set up input amps for analog loopback */
14950         /* Amp Indices: DAC = 0, mixer = 1 */
14951         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14952         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14953         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14954         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14955         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14956         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14957         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14958         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14959
14960         { }
14961 };
14962
14963 /*
14964  * 3-stack pin configuration:
14965  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
14966  */
14967 static struct hda_verb alc861vd_3stack_init_verbs[] = {
14968         /*
14969          * Set pin mode and muting
14970          */
14971         /* set front pin widgets 0x14 for output */
14972         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
14973         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14974         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
14975
14976         /* Mic (rear) pin: input vref at 80% */
14977         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14978         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14979         /* Front Mic pin: input vref at 80% */
14980         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
14981         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14982         /* Line In pin: input */
14983         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14984         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14985         /* Line-2 In: Headphone output (output 0 - 0x0c) */
14986         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
14987         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14988         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
14989         /* CD pin widget for input */
14990         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
14991
14992         { }
14993 };
14994
14995 /*
14996  * 6-stack pin configuration:
14997  */
14998 static struct hda_verb alc861vd_6stack_init_verbs[] = {
14999         /*
15000          * Set pin mode and muting
15001          */
15002         /* set front pin widgets 0x14 for output */
15003         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15004         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15005         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15006
15007         /* Rear Pin: output 1 (0x0d) */
15008         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15009         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15010         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15011         /* CLFE Pin: output 2 (0x0e) */
15012         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15013         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15014         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15015         /* Side Pin: output 3 (0x0f) */
15016         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15017         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15018         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15019
15020         /* Mic (rear) pin: input vref at 80% */
15021         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15022         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15023         /* Front Mic pin: input vref at 80% */
15024         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15025         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15026         /* Line In pin: input */
15027         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15028         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15029         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15030         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15031         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15032         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15033         /* CD pin widget for input */
15034         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15035
15036         { }
15037 };
15038
15039 static struct hda_verb alc861vd_eapd_verbs[] = {
15040         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15041         { }
15042 };
15043
15044 static struct hda_verb alc660vd_eapd_verbs[] = {
15045         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15046         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15047         { }
15048 };
15049
15050 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15051         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15052         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15053         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15054         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15055         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15056         {}
15057 };
15058
15059 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15060 {
15061         unsigned int present;
15062         unsigned char bits;
15063
15064         present = snd_hda_codec_read(codec, 0x18, 0,
15065                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
15066         bits = present ? HDA_AMP_MUTE : 0;
15067         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15068                                  HDA_AMP_MUTE, bits);
15069 }
15070
15071 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15072 {
15073         struct alc_spec *spec = codec->spec;
15074         spec->autocfg.hp_pins[0] = 0x1b;
15075         spec->autocfg.speaker_pins[0] = 0x14;
15076 }
15077
15078 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15079 {
15080         alc_automute_amp(codec);
15081         alc861vd_lenovo_mic_automute(codec);
15082 }
15083
15084 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15085                                         unsigned int res)
15086 {
15087         switch (res >> 26) {
15088         case ALC880_MIC_EVENT:
15089                 alc861vd_lenovo_mic_automute(codec);
15090                 break;
15091         default:
15092                 alc_automute_amp_unsol_event(codec, res);
15093                 break;
15094         }
15095 }
15096
15097 static struct hda_verb alc861vd_dallas_verbs[] = {
15098         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15099         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15100         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15101         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15102
15103         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15104         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15105         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15106         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15107         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15108         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15109         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15110         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15111
15112         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15113         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15114         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15115         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15116         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15117         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15118         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15119         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15120
15121         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15122         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15123         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15124         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15125         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15126         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15127         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15128         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15129
15130         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15131         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15132         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15134
15135         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15136         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15137         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15138
15139         { } /* end */
15140 };
15141
15142 /* toggle speaker-output according to the hp-jack state */
15143 static void alc861vd_dallas_setup(struct hda_codec *codec)
15144 {
15145         struct alc_spec *spec = codec->spec;
15146
15147         spec->autocfg.hp_pins[0] = 0x15;
15148         spec->autocfg.speaker_pins[0] = 0x14;
15149 }
15150
15151 #ifdef CONFIG_SND_HDA_POWER_SAVE
15152 #define alc861vd_loopbacks      alc880_loopbacks
15153 #endif
15154
15155 /* pcm configuration: identical with ALC880 */
15156 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15157 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15158 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15159 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15160
15161 /*
15162  * configuration and preset
15163  */
15164 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15165         [ALC660VD_3ST]          = "3stack-660",
15166         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15167         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15168         [ALC861VD_3ST]          = "3stack",
15169         [ALC861VD_3ST_DIG]      = "3stack-digout",
15170         [ALC861VD_6ST_DIG]      = "6stack-digout",
15171         [ALC861VD_LENOVO]       = "lenovo",
15172         [ALC861VD_DALLAS]       = "dallas",
15173         [ALC861VD_HP]           = "hp",
15174         [ALC861VD_AUTO]         = "auto",
15175 };
15176
15177 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15178         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15179         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15180         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15181         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15182         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15183         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15184         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15185         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15186         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15187         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15188         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15189         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15190         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15191         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15192         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15193         {}
15194 };
15195
15196 static struct alc_config_preset alc861vd_presets[] = {
15197         [ALC660VD_3ST] = {
15198                 .mixers = { alc861vd_3st_mixer },
15199                 .init_verbs = { alc861vd_volume_init_verbs,
15200                                  alc861vd_3stack_init_verbs },
15201                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15202                 .dac_nids = alc660vd_dac_nids,
15203                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15204                 .channel_mode = alc861vd_3stack_2ch_modes,
15205                 .input_mux = &alc861vd_capture_source,
15206         },
15207         [ALC660VD_3ST_DIG] = {
15208                 .mixers = { alc861vd_3st_mixer },
15209                 .init_verbs = { alc861vd_volume_init_verbs,
15210                                  alc861vd_3stack_init_verbs },
15211                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15212                 .dac_nids = alc660vd_dac_nids,
15213                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15214                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15215                 .channel_mode = alc861vd_3stack_2ch_modes,
15216                 .input_mux = &alc861vd_capture_source,
15217         },
15218         [ALC861VD_3ST] = {
15219                 .mixers = { alc861vd_3st_mixer },
15220                 .init_verbs = { alc861vd_volume_init_verbs,
15221                                  alc861vd_3stack_init_verbs },
15222                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15223                 .dac_nids = alc861vd_dac_nids,
15224                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15225                 .channel_mode = alc861vd_3stack_2ch_modes,
15226                 .input_mux = &alc861vd_capture_source,
15227         },
15228         [ALC861VD_3ST_DIG] = {
15229                 .mixers = { alc861vd_3st_mixer },
15230                 .init_verbs = { alc861vd_volume_init_verbs,
15231                                  alc861vd_3stack_init_verbs },
15232                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15233                 .dac_nids = alc861vd_dac_nids,
15234                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15235                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15236                 .channel_mode = alc861vd_3stack_2ch_modes,
15237                 .input_mux = &alc861vd_capture_source,
15238         },
15239         [ALC861VD_6ST_DIG] = {
15240                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15241                 .init_verbs = { alc861vd_volume_init_verbs,
15242                                 alc861vd_6stack_init_verbs },
15243                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15244                 .dac_nids = alc861vd_dac_nids,
15245                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15246                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
15247                 .channel_mode = alc861vd_6stack_modes,
15248                 .input_mux = &alc861vd_capture_source,
15249         },
15250         [ALC861VD_LENOVO] = {
15251                 .mixers = { alc861vd_lenovo_mixer },
15252                 .init_verbs = { alc861vd_volume_init_verbs,
15253                                 alc861vd_3stack_init_verbs,
15254                                 alc861vd_eapd_verbs,
15255                                 alc861vd_lenovo_unsol_verbs },
15256                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15257                 .dac_nids = alc660vd_dac_nids,
15258                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15259                 .channel_mode = alc861vd_3stack_2ch_modes,
15260                 .input_mux = &alc861vd_capture_source,
15261                 .unsol_event = alc861vd_lenovo_unsol_event,
15262                 .setup = alc861vd_lenovo_setup,
15263                 .init_hook = alc861vd_lenovo_init_hook,
15264         },
15265         [ALC861VD_DALLAS] = {
15266                 .mixers = { alc861vd_dallas_mixer },
15267                 .init_verbs = { alc861vd_dallas_verbs },
15268                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15269                 .dac_nids = alc861vd_dac_nids,
15270                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15271                 .channel_mode = alc861vd_3stack_2ch_modes,
15272                 .input_mux = &alc861vd_dallas_capture_source,
15273                 .unsol_event = alc_automute_amp_unsol_event,
15274                 .setup = alc861vd_dallas_setup,
15275                 .init_hook = alc_automute_amp,
15276         },
15277         [ALC861VD_HP] = {
15278                 .mixers = { alc861vd_hp_mixer },
15279                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
15280                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15281                 .dac_nids = alc861vd_dac_nids,
15282                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15283                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15284                 .channel_mode = alc861vd_3stack_2ch_modes,
15285                 .input_mux = &alc861vd_hp_capture_source,
15286                 .unsol_event = alc_automute_amp_unsol_event,
15287                 .setup = alc861vd_dallas_setup,
15288                 .init_hook = alc_automute_amp,
15289         },
15290         [ALC660VD_ASUS_V1S] = {
15291                 .mixers = { alc861vd_lenovo_mixer },
15292                 .init_verbs = { alc861vd_volume_init_verbs,
15293                                 alc861vd_3stack_init_verbs,
15294                                 alc861vd_eapd_verbs,
15295                                 alc861vd_lenovo_unsol_verbs },
15296                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15297                 .dac_nids = alc660vd_dac_nids,
15298                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15299                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15300                 .channel_mode = alc861vd_3stack_2ch_modes,
15301                 .input_mux = &alc861vd_capture_source,
15302                 .unsol_event = alc861vd_lenovo_unsol_event,
15303                 .setup = alc861vd_lenovo_setup,
15304                 .init_hook = alc861vd_lenovo_init_hook,
15305         },
15306 };
15307
15308 /*
15309  * BIOS auto configuration
15310  */
15311 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
15312                                                 const struct auto_pin_cfg *cfg)
15313 {
15314         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
15315 }
15316
15317
15318 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
15319                                 hda_nid_t nid, int pin_type, int dac_idx)
15320 {
15321         alc_set_pin_output(codec, nid, pin_type);
15322 }
15323
15324 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
15325 {
15326         struct alc_spec *spec = codec->spec;
15327         int i;
15328
15329         for (i = 0; i <= HDA_SIDE; i++) {
15330                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15331                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15332                 if (nid)
15333                         alc861vd_auto_set_output_and_unmute(codec, nid,
15334                                                             pin_type, i);
15335         }
15336 }
15337
15338
15339 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
15340 {
15341         struct alc_spec *spec = codec->spec;
15342         hda_nid_t pin;
15343
15344         pin = spec->autocfg.hp_pins[0];
15345         if (pin) /* connect to front and use dac 0 */
15346                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
15347         pin = spec->autocfg.speaker_pins[0];
15348         if (pin)
15349                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
15350 }
15351
15352 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
15353
15354 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
15355 {
15356         struct alc_spec *spec = codec->spec;
15357         int i;
15358
15359         for (i = 0; i < AUTO_PIN_LAST; i++) {
15360                 hda_nid_t nid = spec->autocfg.input_pins[i];
15361                 if (alc_is_input_pin(codec, nid)) {
15362                         alc_set_input_pin(codec, nid, i);
15363                         if (nid != ALC861VD_PIN_CD_NID &&
15364                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
15365                                 snd_hda_codec_write(codec, nid, 0,
15366                                                 AC_VERB_SET_AMP_GAIN_MUTE,
15367                                                 AMP_OUT_MUTE);
15368                 }
15369         }
15370 }
15371
15372 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
15373
15374 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
15375 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
15376
15377 /* add playback controls from the parsed DAC table */
15378 /* Based on ALC880 version. But ALC861VD has separate,
15379  * different NIDs for mute/unmute switch and volume control */
15380 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
15381                                              const struct auto_pin_cfg *cfg)
15382 {
15383         char name[32];
15384         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
15385         hda_nid_t nid_v, nid_s;
15386         int i, err;
15387
15388         for (i = 0; i < cfg->line_outs; i++) {
15389                 if (!spec->multiout.dac_nids[i])
15390                         continue;
15391                 nid_v = alc861vd_idx_to_mixer_vol(
15392                                 alc880_dac_to_idx(
15393                                         spec->multiout.dac_nids[i]));
15394                 nid_s = alc861vd_idx_to_mixer_switch(
15395                                 alc880_dac_to_idx(
15396                                         spec->multiout.dac_nids[i]));
15397
15398                 if (i == 2) {
15399                         /* Center/LFE */
15400                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15401                                           "Center Playback Volume",
15402                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
15403                                                               HDA_OUTPUT));
15404                         if (err < 0)
15405                                 return err;
15406                         err = add_control(spec, ALC_CTL_WIDGET_VOL,
15407                                           "LFE Playback Volume",
15408                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
15409                                                               HDA_OUTPUT));
15410                         if (err < 0)
15411                                 return err;
15412                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15413                                           "Center Playback Switch",
15414                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
15415                                                               HDA_INPUT));
15416                         if (err < 0)
15417                                 return err;
15418                         err = add_control(spec, ALC_CTL_BIND_MUTE,
15419                                           "LFE Playback Switch",
15420                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
15421                                                               HDA_INPUT));
15422                         if (err < 0)
15423                                 return err;
15424                 } else {
15425                         const char *pfx;
15426                         if (cfg->line_outs == 1 &&
15427                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
15428                                 if (!cfg->hp_pins)
15429                                         pfx = "Speaker";
15430                                 else
15431                                         pfx = "PCM";
15432                         } else
15433                                 pfx = chname[i];
15434                         sprintf(name, "%s Playback Volume", pfx);
15435                         err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15436                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
15437                                                               HDA_OUTPUT));
15438                         if (err < 0)
15439                                 return err;
15440                         if (cfg->line_outs == 1 &&
15441                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15442                                 pfx = "Speaker";
15443                         sprintf(name, "%s Playback Switch", pfx);
15444                         err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15445                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
15446                                                               HDA_INPUT));
15447                         if (err < 0)
15448                                 return err;
15449                 }
15450         }
15451         return 0;
15452 }
15453
15454 /* add playback controls for speaker and HP outputs */
15455 /* Based on ALC880 version. But ALC861VD has separate,
15456  * different NIDs for mute/unmute switch and volume control */
15457 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
15458                                         hda_nid_t pin, const char *pfx)
15459 {
15460         hda_nid_t nid_v, nid_s;
15461         int err;
15462         char name[32];
15463
15464         if (!pin)
15465                 return 0;
15466
15467         if (alc880_is_fixed_pin(pin)) {
15468                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
15469                 /* specify the DAC as the extra output */
15470                 if (!spec->multiout.hp_nid)
15471                         spec->multiout.hp_nid = nid_v;
15472                 else
15473                         spec->multiout.extra_out_nid[0] = nid_v;
15474                 /* control HP volume/switch on the output mixer amp */
15475                 nid_v = alc861vd_idx_to_mixer_vol(
15476                                 alc880_fixed_pin_idx(pin));
15477                 nid_s = alc861vd_idx_to_mixer_switch(
15478                                 alc880_fixed_pin_idx(pin));
15479
15480                 sprintf(name, "%s Playback Volume", pfx);
15481                 err = add_control(spec, ALC_CTL_WIDGET_VOL, name,
15482                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
15483                 if (err < 0)
15484                         return err;
15485                 sprintf(name, "%s Playback Switch", pfx);
15486                 err = add_control(spec, ALC_CTL_BIND_MUTE, name,
15487                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
15488                 if (err < 0)
15489                         return err;
15490         } else if (alc880_is_multi_pin(pin)) {
15491                 /* set manual connection */
15492                 /* we have only a switch on HP-out PIN */
15493                 sprintf(name, "%s Playback Switch", pfx);
15494                 err = add_control(spec, ALC_CTL_WIDGET_MUTE, name,
15495                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
15496                 if (err < 0)
15497                         return err;
15498         }
15499         return 0;
15500 }
15501
15502 /* parse the BIOS configuration and set up the alc_spec
15503  * return 1 if successful, 0 if the proper config is not found,
15504  * or a negative error code
15505  * Based on ALC880 version - had to change it to override
15506  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
15507 static int alc861vd_parse_auto_config(struct hda_codec *codec)
15508 {
15509         struct alc_spec *spec = codec->spec;
15510         int err;
15511         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
15512
15513         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15514                                            alc861vd_ignore);
15515         if (err < 0)
15516                 return err;
15517         if (!spec->autocfg.line_outs)
15518                 return 0; /* can't find valid BIOS pin config */
15519
15520         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
15521         if (err < 0)
15522                 return err;
15523         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
15524         if (err < 0)
15525                 return err;
15526         err = alc861vd_auto_create_extra_out(spec,
15527                                              spec->autocfg.speaker_pins[0],
15528                                              "Speaker");
15529         if (err < 0)
15530                 return err;
15531         err = alc861vd_auto_create_extra_out(spec,
15532                                              spec->autocfg.hp_pins[0],
15533                                              "Headphone");
15534         if (err < 0)
15535                 return err;
15536         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
15537         if (err < 0)
15538                 return err;
15539
15540         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15541
15542         if (spec->autocfg.dig_outs)
15543                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
15544
15545         if (spec->kctls.list)
15546                 add_mixer(spec, spec->kctls.list);
15547
15548         add_verb(spec, alc861vd_volume_init_verbs);
15549
15550         spec->num_mux_defs = 1;
15551         spec->input_mux = &spec->private_imux[0];
15552
15553         err = alc_auto_add_mic_boost(codec);
15554         if (err < 0)
15555                 return err;
15556
15557         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
15558
15559         return 1;
15560 }
15561
15562 /* additional initialization for auto-configuration model */
15563 static void alc861vd_auto_init(struct hda_codec *codec)
15564 {
15565         struct alc_spec *spec = codec->spec;
15566         alc861vd_auto_init_multi_out(codec);
15567         alc861vd_auto_init_hp_out(codec);
15568         alc861vd_auto_init_analog_input(codec);
15569         alc861vd_auto_init_input_src(codec);
15570         if (spec->unsol_event)
15571                 alc_inithook(codec);
15572 }
15573
15574 enum {
15575         ALC660VD_FIX_ASUS_GPIO1
15576 };
15577
15578 /* reset GPIO1 */
15579 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
15580         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
15581         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
15582         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
15583         { }
15584 };
15585
15586 static const struct alc_fixup alc861vd_fixups[] = {
15587         [ALC660VD_FIX_ASUS_GPIO1] = {
15588                 .verbs = alc660vd_fix_asus_gpio1_verbs,
15589         },
15590 };
15591
15592 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
15593         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
15594         {}
15595 };
15596
15597 static int patch_alc861vd(struct hda_codec *codec)
15598 {
15599         struct alc_spec *spec;
15600         int err, board_config;
15601
15602         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15603         if (spec == NULL)
15604                 return -ENOMEM;
15605
15606         codec->spec = spec;
15607
15608         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
15609                                                   alc861vd_models,
15610                                                   alc861vd_cfg_tbl);
15611
15612         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
15613                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15614                        codec->chip_name);
15615                 board_config = ALC861VD_AUTO;
15616         }
15617
15618         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
15619
15620         if (board_config == ALC861VD_AUTO) {
15621                 /* automatic parse from the BIOS config */
15622                 err = alc861vd_parse_auto_config(codec);
15623                 if (err < 0) {
15624                         alc_free(codec);
15625                         return err;
15626                 } else if (!err) {
15627                         printk(KERN_INFO
15628                                "hda_codec: Cannot set up configuration "
15629                                "from BIOS.  Using base mode...\n");
15630                         board_config = ALC861VD_3ST;
15631                 }
15632         }
15633
15634         err = snd_hda_attach_beep_device(codec, 0x23);
15635         if (err < 0) {
15636                 alc_free(codec);
15637                 return err;
15638         }
15639
15640         if (board_config != ALC861VD_AUTO)
15641                 setup_preset(codec, &alc861vd_presets[board_config]);
15642
15643         if (codec->vendor_id == 0x10ec0660) {
15644                 /* always turn on EAPD */
15645                 add_verb(spec, alc660vd_eapd_verbs);
15646         }
15647
15648         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
15649         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
15650
15651         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
15652         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
15653
15654         if (!spec->adc_nids) {
15655                 spec->adc_nids = alc861vd_adc_nids;
15656                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
15657         }
15658         if (!spec->capsrc_nids)
15659                 spec->capsrc_nids = alc861vd_capsrc_nids;
15660
15661         set_capture_mixer(codec);
15662         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
15663
15664         spec->vmaster_nid = 0x02;
15665
15666         codec->patch_ops = alc_patch_ops;
15667
15668         if (board_config == ALC861VD_AUTO)
15669                 spec->init_hook = alc861vd_auto_init;
15670 #ifdef CONFIG_SND_HDA_POWER_SAVE
15671         if (!spec->loopback.amplist)
15672                 spec->loopback.amplist = alc861vd_loopbacks;
15673 #endif
15674         codec->proc_widget_hook = print_realtek_coef;
15675
15676         return 0;
15677 }
15678
15679 /*
15680  * ALC662 support
15681  *
15682  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
15683  * configuration.  Each pin widget can choose any input DACs and a mixer.
15684  * Each ADC is connected from a mixer of all inputs.  This makes possible
15685  * 6-channel independent captures.
15686  *
15687  * In addition, an independent DAC for the multi-playback (not used in this
15688  * driver yet).
15689  */
15690 #define ALC662_DIGOUT_NID       0x06
15691 #define ALC662_DIGIN_NID        0x0a
15692
15693 static hda_nid_t alc662_dac_nids[4] = {
15694         /* front, rear, clfe, rear_surr */
15695         0x02, 0x03, 0x04
15696 };
15697
15698 static hda_nid_t alc272_dac_nids[2] = {
15699         0x02, 0x03
15700 };
15701
15702 static hda_nid_t alc662_adc_nids[2] = {
15703         /* ADC1-2 */
15704         0x09, 0x08
15705 };
15706
15707 static hda_nid_t alc272_adc_nids[1] = {
15708         /* ADC1-2 */
15709         0x08,
15710 };
15711
15712 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
15713 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
15714
15715
15716 /* input MUX */
15717 /* FIXME: should be a matrix-type input source selection */
15718 static struct hda_input_mux alc662_capture_source = {
15719         .num_items = 4,
15720         .items = {
15721                 { "Mic", 0x0 },
15722                 { "Front Mic", 0x1 },
15723                 { "Line", 0x2 },
15724                 { "CD", 0x4 },
15725         },
15726 };
15727
15728 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
15729         .num_items = 2,
15730         .items = {
15731                 { "Mic", 0x1 },
15732                 { "Line", 0x2 },
15733         },
15734 };
15735
15736 static struct hda_input_mux alc663_capture_source = {
15737         .num_items = 3,
15738         .items = {
15739                 { "Mic", 0x0 },
15740                 { "Front Mic", 0x1 },
15741                 { "Line", 0x2 },
15742         },
15743 };
15744
15745 #if 0 /* set to 1 for testing other input sources below */
15746 static struct hda_input_mux alc272_nc10_capture_source = {
15747         .num_items = 16,
15748         .items = {
15749                 { "Autoselect Mic", 0x0 },
15750                 { "Internal Mic", 0x1 },
15751                 { "In-0x02", 0x2 },
15752                 { "In-0x03", 0x3 },
15753                 { "In-0x04", 0x4 },
15754                 { "In-0x05", 0x5 },
15755                 { "In-0x06", 0x6 },
15756                 { "In-0x07", 0x7 },
15757                 { "In-0x08", 0x8 },
15758                 { "In-0x09", 0x9 },
15759                 { "In-0x0a", 0x0a },
15760                 { "In-0x0b", 0x0b },
15761                 { "In-0x0c", 0x0c },
15762                 { "In-0x0d", 0x0d },
15763                 { "In-0x0e", 0x0e },
15764                 { "In-0x0f", 0x0f },
15765         },
15766 };
15767 #endif
15768
15769 /*
15770  * 2ch mode
15771  */
15772 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
15773         { 2, NULL }
15774 };
15775
15776 /*
15777  * 2ch mode
15778  */
15779 static struct hda_verb alc662_3ST_ch2_init[] = {
15780         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
15781         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15782         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
15783         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
15784         { } /* end */
15785 };
15786
15787 /*
15788  * 6ch mode
15789  */
15790 static struct hda_verb alc662_3ST_ch6_init[] = {
15791         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15792         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15793         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
15794         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15795         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
15796         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
15797         { } /* end */
15798 };
15799
15800 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
15801         { 2, alc662_3ST_ch2_init },
15802         { 6, alc662_3ST_ch6_init },
15803 };
15804
15805 /*
15806  * 2ch mode
15807  */
15808 static struct hda_verb alc662_sixstack_ch6_init[] = {
15809         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15810         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15811         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15812         { } /* end */
15813 };
15814
15815 /*
15816  * 6ch mode
15817  */
15818 static struct hda_verb alc662_sixstack_ch8_init[] = {
15819         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15820         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15821         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15822         { } /* end */
15823 };
15824
15825 static struct hda_channel_mode alc662_5stack_modes[2] = {
15826         { 2, alc662_sixstack_ch6_init },
15827         { 6, alc662_sixstack_ch8_init },
15828 };
15829
15830 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15831  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15832  */
15833
15834 static struct snd_kcontrol_new alc662_base_mixer[] = {
15835         /* output mixer control */
15836         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
15837         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15838         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
15839         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15840         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15841         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15842         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15843         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15844         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15845
15846         /*Input mixer control */
15847         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
15848         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
15849         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
15850         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
15851         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
15852         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
15853         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
15854         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
15855         { } /* end */
15856 };
15857
15858 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
15859         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15860         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15861         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15862         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15863         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15864         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15865         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15866         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15867         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15868         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15869         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15870         { } /* end */
15871 };
15872
15873 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
15874         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15875         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
15876         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15877         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
15878         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15879         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15880         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
15881         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
15882         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15883         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15884         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15885         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15886         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15887         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15888         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15889         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15890         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15891         { } /* end */
15892 };
15893
15894 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
15895         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15896         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
15897         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15898         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
15899         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15900         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15901         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15902         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15903         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15904         { } /* end */
15905 };
15906
15907 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
15908         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15909         ALC262_HIPPO_MASTER_SWITCH,
15910
15911         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
15912         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15913         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15914
15915         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
15916         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15917         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15918         { } /* end */
15919 };
15920
15921 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
15922         ALC262_HIPPO_MASTER_SWITCH,
15923         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15924         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15925         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
15926         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
15927         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
15928         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15929         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15930         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15931         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15932         { } /* end */
15933 };
15934
15935 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
15936         .ops = &snd_hda_bind_vol,
15937         .values = {
15938                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
15939                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
15940                 0
15941         },
15942 };
15943
15944 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
15945         .ops = &snd_hda_bind_sw,
15946         .values = {
15947                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15948                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15949                 0
15950         },
15951 };
15952
15953 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
15954         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15955         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
15956         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15957         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15958         { } /* end */
15959 };
15960
15961 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
15962         .ops = &snd_hda_bind_sw,
15963         .values = {
15964                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15965                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15966                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
15967                 0
15968         },
15969 };
15970
15971 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
15972         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15973         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
15974         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15975         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15976         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15977         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15978
15979         { } /* end */
15980 };
15981
15982 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
15983         .ops = &snd_hda_bind_sw,
15984         .values = {
15985                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
15986                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
15987                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
15988                 0
15989         },
15990 };
15991
15992 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
15993         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
15994         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
15995         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15996         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15997         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15998         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15999         { } /* end */
16000 };
16001
16002 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16003         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16004         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16005         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16006         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16007         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16008         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16009         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16010         { } /* end */
16011 };
16012
16013 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16014         .ops = &snd_hda_bind_vol,
16015         .values = {
16016                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16017                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16018                 0
16019         },
16020 };
16021
16022 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16023         .ops = &snd_hda_bind_sw,
16024         .values = {
16025                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16026                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16027                 0
16028         },
16029 };
16030
16031 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16032         HDA_BIND_VOL("Master Playback Volume",
16033                                 &alc663_asus_two_bind_master_vol),
16034         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16035         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16036         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16038         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16039         { } /* end */
16040 };
16041
16042 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16043         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16044         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16045         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16046         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16047         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16048         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16049         { } /* end */
16050 };
16051
16052 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16053         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16054         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16055         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16056         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16057         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16058
16059         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16060         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16061         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16062         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16063         { } /* end */
16064 };
16065
16066 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16067         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16068         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16069         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16070
16071         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16072         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16073         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16074         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16075         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16076         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16077         { } /* end */
16078 };
16079
16080 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16081         {
16082                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16083                 .name = "Channel Mode",
16084                 .info = alc_ch_mode_info,
16085                 .get = alc_ch_mode_get,
16086                 .put = alc_ch_mode_put,
16087         },
16088         { } /* end */
16089 };
16090
16091 static struct hda_verb alc662_init_verbs[] = {
16092         /* ADC: mute amp left and right */
16093         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16094         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16095         /* Front mixer: unmute input/output amp left and right (volume = 0) */
16096
16097         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16098         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16099         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16100         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16101         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16102
16103         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16104         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16105         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16106         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16107         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16108         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16109
16110         /* Front Pin: output 0 (0x0c) */
16111         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16112         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16113
16114         /* Rear Pin: output 1 (0x0d) */
16115         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16116         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16117
16118         /* CLFE Pin: output 2 (0x0e) */
16119         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16120         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16121
16122         /* Mic (rear) pin: input vref at 80% */
16123         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16124         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16125         /* Front Mic pin: input vref at 80% */
16126         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16127         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16128         /* Line In pin: input */
16129         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16130         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16131         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16132         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16133         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16134         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16135         /* CD pin widget for input */
16136         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16137
16138         /* FIXME: use matrix-type input source selection */
16139         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16140         /* Input mixer */
16141         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16142         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16143
16144         /* always trun on EAPD */
16145         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16146         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16147
16148         { }
16149 };
16150
16151 static struct hda_verb alc662_sue_init_verbs[] = {
16152         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16153         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16154         {}
16155 };
16156
16157 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16158         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16159         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16160         {}
16161 };
16162
16163 /* Set Unsolicited Event*/
16164 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16165         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16166         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16167         {}
16168 };
16169
16170 /*
16171  * generic initialization of ADC, input mixers and output mixers
16172  */
16173 static struct hda_verb alc662_auto_init_verbs[] = {
16174         /*
16175          * Unmute ADC and set the default input to mic-in
16176          */
16177         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16178         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16179
16180         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
16181          * mixer widget
16182          * Note: PASD motherboards uses the Line In 2 as the input for front
16183          * panel mic (mic 2)
16184          */
16185         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
16186         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16187         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
16188         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
16189         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
16190         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
16191
16192         /*
16193          * Set up output mixers (0x0c - 0x0f)
16194          */
16195         /* set vol=0 to output mixers */
16196         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16197         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16198         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
16199
16200         /* set up input amps for analog loopback */
16201         /* Amp Indices: DAC = 0, mixer = 1 */
16202         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16203         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16204         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16205         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16206         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16207         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16208
16209
16210         /* FIXME: use matrix-type input source selection */
16211         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16212         /* Input mixer */
16213         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16214         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16215         { }
16216 };
16217
16218 /* additional verbs for ALC663 */
16219 static struct hda_verb alc663_auto_init_verbs[] = {
16220         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16221         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16222         { }
16223 };
16224
16225 static struct hda_verb alc663_m51va_init_verbs[] = {
16226         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16227         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16228         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16229         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16230         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16231         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16232         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16233         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16234         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16235         {}
16236 };
16237
16238 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16239         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16240         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16241         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16242         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16243         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16244         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16245         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16246         {}
16247 };
16248
16249 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
16250         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16251         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16252         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16253         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16254         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16255         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16256         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16257         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16258         {}
16259 };
16260
16261 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
16262         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16263         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16264         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16265         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16266         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16267         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16268         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16269         {}
16270 };
16271
16272 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
16273         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16274         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16275         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16276         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16277         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16278         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16279         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
16280         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16281         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16282         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16283         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16284         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16285         {}
16286 };
16287
16288 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
16289         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16290         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16291         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16292         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16293         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16294         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16295         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16296         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16297         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16298         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16299         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16300         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16301         {}
16302 };
16303
16304 static struct hda_verb alc663_g71v_init_verbs[] = {
16305         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16306         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
16307         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
16308
16309         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16310         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16311         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16312
16313         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16314         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
16315         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16316         {}
16317 };
16318
16319 static struct hda_verb alc663_g50v_init_verbs[] = {
16320         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16321         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16322         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
16323
16324         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16325         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16326         {}
16327 };
16328
16329 static struct hda_verb alc662_ecs_init_verbs[] = {
16330         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
16331         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16332         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16333         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16334         {}
16335 };
16336
16337 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
16338         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16339         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16340         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16341         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16342         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16343         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16344         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16345         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16346         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16347         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16348         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16349         {}
16350 };
16351
16352 static struct hda_verb alc272_dell_init_verbs[] = {
16353         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16354         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16355         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16356         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16357         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16358         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16359         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16360         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16361         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16362         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16363         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16364         {}
16365 };
16366
16367 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
16368         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
16369         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
16370         { } /* end */
16371 };
16372
16373 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
16374         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
16375         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
16376         { } /* end */
16377 };
16378
16379 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
16380 {
16381         unsigned int present;
16382         unsigned char bits;
16383
16384         present = snd_hda_codec_read(codec, 0x14, 0,
16385                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16386         bits = present ? HDA_AMP_MUTE : 0;
16387         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16388                                  HDA_AMP_MUTE, bits);
16389 }
16390
16391 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
16392 {
16393         unsigned int present;
16394         unsigned char bits;
16395
16396         present = snd_hda_codec_read(codec, 0x1b, 0,
16397                                      AC_VERB_GET_PIN_SENSE, 0) & 0x80000000;
16398         bits = present ? HDA_AMP_MUTE : 0;
16399         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16400                                  HDA_AMP_MUTE, bits);
16401         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16402                                  HDA_AMP_MUTE, bits);
16403 }
16404
16405 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
16406                                            unsigned int res)
16407 {
16408         if ((res >> 26) == ALC880_HP_EVENT)
16409                 alc662_lenovo_101e_all_automute(codec);
16410         if ((res >> 26) == ALC880_FRONT_EVENT)
16411                 alc662_lenovo_101e_ispeaker_automute(codec);
16412 }
16413
16414 /* unsolicited event for HP jack sensing */
16415 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
16416                                      unsigned int res)
16417 {
16418         if ((res >> 26) == ALC880_MIC_EVENT)
16419                 alc_mic_automute(codec);
16420         else
16421                 alc262_hippo_unsol_event(codec, res);
16422 }
16423
16424 static void alc662_eeepc_setup(struct hda_codec *codec)
16425 {
16426         struct alc_spec *spec = codec->spec;
16427
16428         alc262_hippo1_setup(codec);
16429         spec->ext_mic.pin = 0x18;
16430         spec->ext_mic.mux_idx = 0;
16431         spec->int_mic.pin = 0x19;
16432         spec->int_mic.mux_idx = 1;
16433         spec->auto_mic = 1;
16434 }
16435
16436 static void alc662_eeepc_inithook(struct hda_codec *codec)
16437 {
16438         alc262_hippo_automute(codec);
16439         alc_mic_automute(codec);
16440 }
16441
16442 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
16443 {
16444         struct alc_spec *spec = codec->spec;
16445
16446         spec->autocfg.hp_pins[0] = 0x14;
16447         spec->autocfg.speaker_pins[0] = 0x1b;
16448 }
16449
16450 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
16451
16452 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
16453 {
16454         unsigned int present;
16455         unsigned char bits;
16456
16457         present = snd_hda_codec_read(codec, 0x21, 0,
16458                         AC_VERB_GET_PIN_SENSE, 0)
16459                         & AC_PINSENSE_PRESENCE;
16460         bits = present ? HDA_AMP_MUTE : 0;
16461         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16462                                 AMP_IN_MUTE(0), bits);
16463         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16464                                 AMP_IN_MUTE(0), bits);
16465 }
16466
16467 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
16468 {
16469         unsigned int present;
16470         unsigned char bits;
16471
16472         present = snd_hda_codec_read(codec, 0x21, 0,
16473                         AC_VERB_GET_PIN_SENSE, 0)
16474                         & AC_PINSENSE_PRESENCE;
16475         bits = present ? HDA_AMP_MUTE : 0;
16476         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16477                                 AMP_IN_MUTE(0), bits);
16478         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16479                                 AMP_IN_MUTE(0), bits);
16480         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16481                                 AMP_IN_MUTE(0), bits);
16482         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16483                                 AMP_IN_MUTE(0), bits);
16484 }
16485
16486 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
16487 {
16488         unsigned int present;
16489         unsigned char bits;
16490
16491         present = snd_hda_codec_read(codec, 0x15, 0,
16492                         AC_VERB_GET_PIN_SENSE, 0)
16493                         & AC_PINSENSE_PRESENCE;
16494         bits = present ? HDA_AMP_MUTE : 0;
16495         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16496                                 AMP_IN_MUTE(0), bits);
16497         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16498                                 AMP_IN_MUTE(0), bits);
16499         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
16500                                 AMP_IN_MUTE(0), bits);
16501         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
16502                                 AMP_IN_MUTE(0), bits);
16503 }
16504
16505 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
16506 {
16507         unsigned int present;
16508         unsigned char bits;
16509
16510         present = snd_hda_codec_read(codec, 0x1b, 0,
16511                         AC_VERB_GET_PIN_SENSE, 0)
16512                         & AC_PINSENSE_PRESENCE;
16513         bits = present ? 0 : PIN_OUT;
16514         snd_hda_codec_write(codec, 0x14, 0,
16515                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
16516 }
16517
16518 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
16519 {
16520         unsigned int present1, present2;
16521
16522         present1 = snd_hda_codec_read(codec, 0x21, 0,
16523                         AC_VERB_GET_PIN_SENSE, 0)
16524                         & AC_PINSENSE_PRESENCE;
16525         present2 = snd_hda_codec_read(codec, 0x15, 0,
16526                         AC_VERB_GET_PIN_SENSE, 0)
16527                         & AC_PINSENSE_PRESENCE;
16528
16529         if (present1 || present2) {
16530                 snd_hda_codec_write_cache(codec, 0x14, 0,
16531                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
16532         } else {
16533                 snd_hda_codec_write_cache(codec, 0x14, 0,
16534                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
16535         }
16536 }
16537
16538 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
16539 {
16540         unsigned int present1, present2;
16541
16542         present1 = snd_hda_codec_read(codec, 0x1b, 0,
16543                                 AC_VERB_GET_PIN_SENSE, 0)
16544                                 & AC_PINSENSE_PRESENCE;
16545         present2 = snd_hda_codec_read(codec, 0x15, 0,
16546                                 AC_VERB_GET_PIN_SENSE, 0)
16547                                 & AC_PINSENSE_PRESENCE;
16548
16549         if (present1 || present2) {
16550                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16551                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16552                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16553                                 AMP_IN_MUTE(0), AMP_IN_MUTE(0));
16554         } else {
16555                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
16556                                 AMP_IN_MUTE(0), 0);
16557                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
16558                                 AMP_IN_MUTE(0), 0);
16559         }
16560 }
16561
16562 static void alc663_m51va_unsol_event(struct hda_codec *codec,
16563                                            unsigned int res)
16564 {
16565         switch (res >> 26) {
16566         case ALC880_HP_EVENT:
16567                 alc663_m51va_speaker_automute(codec);
16568                 break;
16569         case ALC880_MIC_EVENT:
16570                 alc_mic_automute(codec);
16571                 break;
16572         }
16573 }
16574
16575 static void alc663_m51va_setup(struct hda_codec *codec)
16576 {
16577         struct alc_spec *spec = codec->spec;
16578         spec->ext_mic.pin = 0x18;
16579         spec->ext_mic.mux_idx = 0;
16580         spec->int_mic.pin = 0x12;
16581         spec->int_mic.mux_idx = 1;
16582         spec->auto_mic = 1;
16583 }
16584
16585 static void alc663_m51va_inithook(struct hda_codec *codec)
16586 {
16587         alc663_m51va_speaker_automute(codec);
16588         alc_mic_automute(codec);
16589 }
16590
16591 /* ***************** Mode1 ******************************/
16592 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
16593 #define alc663_mode1_setup              alc663_m51va_setup
16594 #define alc663_mode1_inithook           alc663_m51va_inithook
16595
16596 /* ***************** Mode2 ******************************/
16597 static void alc662_mode2_unsol_event(struct hda_codec *codec,
16598                                            unsigned int res)
16599 {
16600         switch (res >> 26) {
16601         case ALC880_HP_EVENT:
16602                 alc662_f5z_speaker_automute(codec);
16603                 break;
16604         case ALC880_MIC_EVENT:
16605                 alc_mic_automute(codec);
16606                 break;
16607         }
16608 }
16609
16610 #define alc662_mode2_setup      alc663_m51va_setup
16611
16612 static void alc662_mode2_inithook(struct hda_codec *codec)
16613 {
16614         alc662_f5z_speaker_automute(codec);
16615         alc_mic_automute(codec);
16616 }
16617 /* ***************** Mode3 ******************************/
16618 static void alc663_mode3_unsol_event(struct hda_codec *codec,
16619                                            unsigned int res)
16620 {
16621         switch (res >> 26) {
16622         case ALC880_HP_EVENT:
16623                 alc663_two_hp_m1_speaker_automute(codec);
16624                 break;
16625         case ALC880_MIC_EVENT:
16626                 alc_mic_automute(codec);
16627                 break;
16628         }
16629 }
16630
16631 #define alc663_mode3_setup      alc663_m51va_setup
16632
16633 static void alc663_mode3_inithook(struct hda_codec *codec)
16634 {
16635         alc663_two_hp_m1_speaker_automute(codec);
16636         alc_mic_automute(codec);
16637 }
16638 /* ***************** Mode4 ******************************/
16639 static void alc663_mode4_unsol_event(struct hda_codec *codec,
16640                                            unsigned int res)
16641 {
16642         switch (res >> 26) {
16643         case ALC880_HP_EVENT:
16644                 alc663_21jd_two_speaker_automute(codec);
16645                 break;
16646         case ALC880_MIC_EVENT:
16647                 alc_mic_automute(codec);
16648                 break;
16649         }
16650 }
16651
16652 #define alc663_mode4_setup      alc663_m51va_setup
16653
16654 static void alc663_mode4_inithook(struct hda_codec *codec)
16655 {
16656         alc663_21jd_two_speaker_automute(codec);
16657         alc_mic_automute(codec);
16658 }
16659 /* ***************** Mode5 ******************************/
16660 static void alc663_mode5_unsol_event(struct hda_codec *codec,
16661                                            unsigned int res)
16662 {
16663         switch (res >> 26) {
16664         case ALC880_HP_EVENT:
16665                 alc663_15jd_two_speaker_automute(codec);
16666                 break;
16667         case ALC880_MIC_EVENT:
16668                 alc_mic_automute(codec);
16669                 break;
16670         }
16671 }
16672
16673 #define alc663_mode5_setup      alc663_m51va_setup
16674
16675 static void alc663_mode5_inithook(struct hda_codec *codec)
16676 {
16677         alc663_15jd_two_speaker_automute(codec);
16678         alc_mic_automute(codec);
16679 }
16680 /* ***************** Mode6 ******************************/
16681 static void alc663_mode6_unsol_event(struct hda_codec *codec,
16682                                            unsigned int res)
16683 {
16684         switch (res >> 26) {
16685         case ALC880_HP_EVENT:
16686                 alc663_two_hp_m2_speaker_automute(codec);
16687                 break;
16688         case ALC880_MIC_EVENT:
16689                 alc_mic_automute(codec);
16690                 break;
16691         }
16692 }
16693
16694 #define alc663_mode6_setup      alc663_m51va_setup
16695
16696 static void alc663_mode6_inithook(struct hda_codec *codec)
16697 {
16698         alc663_two_hp_m2_speaker_automute(codec);
16699         alc_mic_automute(codec);
16700 }
16701
16702 static void alc663_g71v_hp_automute(struct hda_codec *codec)
16703 {
16704         unsigned int present;
16705         unsigned char bits;
16706
16707         present = snd_hda_codec_read(codec, 0x21, 0,
16708                                      AC_VERB_GET_PIN_SENSE, 0)
16709                 & AC_PINSENSE_PRESENCE;
16710         bits = present ? HDA_AMP_MUTE : 0;
16711         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
16712                                  HDA_AMP_MUTE, bits);
16713         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16714                                  HDA_AMP_MUTE, bits);
16715 }
16716
16717 static void alc663_g71v_front_automute(struct hda_codec *codec)
16718 {
16719         unsigned int present;
16720         unsigned char bits;
16721
16722         present = snd_hda_codec_read(codec, 0x15, 0,
16723                                      AC_VERB_GET_PIN_SENSE, 0)
16724                 & AC_PINSENSE_PRESENCE;
16725         bits = present ? HDA_AMP_MUTE : 0;
16726         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
16727                                  HDA_AMP_MUTE, bits);
16728 }
16729
16730 static void alc663_g71v_unsol_event(struct hda_codec *codec,
16731                                            unsigned int res)
16732 {
16733         switch (res >> 26) {
16734         case ALC880_HP_EVENT:
16735                 alc663_g71v_hp_automute(codec);
16736                 break;
16737         case ALC880_FRONT_EVENT:
16738                 alc663_g71v_front_automute(codec);
16739                 break;
16740         case ALC880_MIC_EVENT:
16741                 alc_mic_automute(codec);
16742                 break;
16743         }
16744 }
16745
16746 #define alc663_g71v_setup       alc663_m51va_setup
16747
16748 static void alc663_g71v_inithook(struct hda_codec *codec)
16749 {
16750         alc663_g71v_front_automute(codec);
16751         alc663_g71v_hp_automute(codec);
16752         alc_mic_automute(codec);
16753 }
16754
16755 static void alc663_g50v_unsol_event(struct hda_codec *codec,
16756                                            unsigned int res)
16757 {
16758         switch (res >> 26) {
16759         case ALC880_HP_EVENT:
16760                 alc663_m51va_speaker_automute(codec);
16761                 break;
16762         case ALC880_MIC_EVENT:
16763                 alc_mic_automute(codec);
16764                 break;
16765         }
16766 }
16767
16768 #define alc663_g50v_setup       alc663_m51va_setup
16769
16770 static void alc663_g50v_inithook(struct hda_codec *codec)
16771 {
16772         alc663_m51va_speaker_automute(codec);
16773         alc_mic_automute(codec);
16774 }
16775
16776 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
16777         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16778         ALC262_HIPPO_MASTER_SWITCH,
16779
16780         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
16781         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
16782         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
16783
16784         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16785         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16786         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16787         { } /* end */
16788 };
16789
16790 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
16791         /* Master Playback automatically created from Speaker and Headphone */
16792         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16793         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16794         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16796
16797         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16798         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16799         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
16800
16801         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16802         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16803         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
16804         { } /* end */
16805 };
16806
16807 #ifdef CONFIG_SND_HDA_POWER_SAVE
16808 #define alc662_loopbacks        alc880_loopbacks
16809 #endif
16810
16811
16812 /* pcm configuration: identical with ALC880 */
16813 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
16814 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
16815 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
16816 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
16817
16818 /*
16819  * configuration and preset
16820  */
16821 static const char *alc662_models[ALC662_MODEL_LAST] = {
16822         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
16823         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
16824         [ALC662_3ST_6ch]        = "3stack-6ch",
16825         [ALC662_5ST_DIG]        = "6stack-dig",
16826         [ALC662_LENOVO_101E]    = "lenovo-101e",
16827         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
16828         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
16829         [ALC662_ECS] = "ecs",
16830         [ALC663_ASUS_M51VA] = "m51va",
16831         [ALC663_ASUS_G71V] = "g71v",
16832         [ALC663_ASUS_H13] = "h13",
16833         [ALC663_ASUS_G50V] = "g50v",
16834         [ALC663_ASUS_MODE1] = "asus-mode1",
16835         [ALC662_ASUS_MODE2] = "asus-mode2",
16836         [ALC663_ASUS_MODE3] = "asus-mode3",
16837         [ALC663_ASUS_MODE4] = "asus-mode4",
16838         [ALC663_ASUS_MODE5] = "asus-mode5",
16839         [ALC663_ASUS_MODE6] = "asus-mode6",
16840         [ALC272_DELL]           = "dell",
16841         [ALC272_DELL_ZM1]       = "dell-zm1",
16842         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
16843         [ALC662_AUTO]           = "auto",
16844 };
16845
16846 static struct snd_pci_quirk alc662_cfg_tbl[] = {
16847         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
16848         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
16849         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
16850         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
16851         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
16852         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
16853         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
16854         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
16855         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
16856         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
16857         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
16858         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
16859         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
16860         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
16861         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
16862         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
16863         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
16864         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
16865         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
16866         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
16867         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
16868         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
16869         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
16870         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
16871         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
16872         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
16873         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
16874         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
16875         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
16876         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
16877         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
16878         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
16879         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
16880         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
16881         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
16882         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
16883         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
16884         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
16885         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
16886         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
16887         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
16888         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
16889         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
16890         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
16891         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
16892         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
16893         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
16894         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
16895         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
16896         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
16897         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
16898         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
16899                       ALC662_3ST_6ch_DIG),
16900         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB200", ALC663_ASUS_MODE4),
16901         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
16902         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
16903                       ALC662_3ST_6ch_DIG),
16904         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
16905         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
16906         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
16907         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
16908                                         ALC662_3ST_6ch_DIG),
16909         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
16910                            ALC663_ASUS_H13),
16911         {}
16912 };
16913
16914 static struct alc_config_preset alc662_presets[] = {
16915         [ALC662_3ST_2ch_DIG] = {
16916                 .mixers = { alc662_3ST_2ch_mixer },
16917                 .init_verbs = { alc662_init_verbs },
16918                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16919                 .dac_nids = alc662_dac_nids,
16920                 .dig_out_nid = ALC662_DIGOUT_NID,
16921                 .dig_in_nid = ALC662_DIGIN_NID,
16922                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16923                 .channel_mode = alc662_3ST_2ch_modes,
16924                 .input_mux = &alc662_capture_source,
16925         },
16926         [ALC662_3ST_6ch_DIG] = {
16927                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16928                 .init_verbs = { alc662_init_verbs },
16929                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16930                 .dac_nids = alc662_dac_nids,
16931                 .dig_out_nid = ALC662_DIGOUT_NID,
16932                 .dig_in_nid = ALC662_DIGIN_NID,
16933                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16934                 .channel_mode = alc662_3ST_6ch_modes,
16935                 .need_dac_fix = 1,
16936                 .input_mux = &alc662_capture_source,
16937         },
16938         [ALC662_3ST_6ch] = {
16939                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
16940                 .init_verbs = { alc662_init_verbs },
16941                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16942                 .dac_nids = alc662_dac_nids,
16943                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16944                 .channel_mode = alc662_3ST_6ch_modes,
16945                 .need_dac_fix = 1,
16946                 .input_mux = &alc662_capture_source,
16947         },
16948         [ALC662_5ST_DIG] = {
16949                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
16950                 .init_verbs = { alc662_init_verbs },
16951                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16952                 .dac_nids = alc662_dac_nids,
16953                 .dig_out_nid = ALC662_DIGOUT_NID,
16954                 .dig_in_nid = ALC662_DIGIN_NID,
16955                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
16956                 .channel_mode = alc662_5stack_modes,
16957                 .input_mux = &alc662_capture_source,
16958         },
16959         [ALC662_LENOVO_101E] = {
16960                 .mixers = { alc662_lenovo_101e_mixer },
16961                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
16962                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16963                 .dac_nids = alc662_dac_nids,
16964                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16965                 .channel_mode = alc662_3ST_2ch_modes,
16966                 .input_mux = &alc662_lenovo_101e_capture_source,
16967                 .unsol_event = alc662_lenovo_101e_unsol_event,
16968                 .init_hook = alc662_lenovo_101e_all_automute,
16969         },
16970         [ALC662_ASUS_EEEPC_P701] = {
16971                 .mixers = { alc662_eeepc_p701_mixer },
16972                 .init_verbs = { alc662_init_verbs,
16973                                 alc662_eeepc_sue_init_verbs },
16974                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16975                 .dac_nids = alc662_dac_nids,
16976                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
16977                 .channel_mode = alc662_3ST_2ch_modes,
16978                 .unsol_event = alc662_eeepc_unsol_event,
16979                 .setup = alc662_eeepc_setup,
16980                 .init_hook = alc662_eeepc_inithook,
16981         },
16982         [ALC662_ASUS_EEEPC_EP20] = {
16983                 .mixers = { alc662_eeepc_ep20_mixer,
16984                             alc662_chmode_mixer },
16985                 .init_verbs = { alc662_init_verbs,
16986                                 alc662_eeepc_ep20_sue_init_verbs },
16987                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
16988                 .dac_nids = alc662_dac_nids,
16989                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
16990                 .channel_mode = alc662_3ST_6ch_modes,
16991                 .input_mux = &alc662_lenovo_101e_capture_source,
16992                 .unsol_event = alc662_eeepc_unsol_event,
16993                 .setup = alc662_eeepc_ep20_setup,
16994                 .init_hook = alc662_eeepc_ep20_inithook,
16995         },
16996         [ALC662_ECS] = {
16997                 .mixers = { alc662_ecs_mixer },
16998                 .init_verbs = { alc662_init_verbs,
16999                                 alc662_ecs_init_verbs },
17000                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17001                 .dac_nids = alc662_dac_nids,
17002                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17003                 .channel_mode = alc662_3ST_2ch_modes,
17004                 .unsol_event = alc662_eeepc_unsol_event,
17005                 .setup = alc662_eeepc_setup,
17006                 .init_hook = alc662_eeepc_inithook,
17007         },
17008         [ALC663_ASUS_M51VA] = {
17009                 .mixers = { alc663_m51va_mixer },
17010                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17011                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17012                 .dac_nids = alc662_dac_nids,
17013                 .dig_out_nid = ALC662_DIGOUT_NID,
17014                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17015                 .channel_mode = alc662_3ST_2ch_modes,
17016                 .unsol_event = alc663_m51va_unsol_event,
17017                 .setup = alc663_m51va_setup,
17018                 .init_hook = alc663_m51va_inithook,
17019         },
17020         [ALC663_ASUS_G71V] = {
17021                 .mixers = { alc663_g71v_mixer },
17022                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17023                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17024                 .dac_nids = alc662_dac_nids,
17025                 .dig_out_nid = ALC662_DIGOUT_NID,
17026                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17027                 .channel_mode = alc662_3ST_2ch_modes,
17028                 .unsol_event = alc663_g71v_unsol_event,
17029                 .setup = alc663_g71v_setup,
17030                 .init_hook = alc663_g71v_inithook,
17031         },
17032         [ALC663_ASUS_H13] = {
17033                 .mixers = { alc663_m51va_mixer },
17034                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17035                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17036                 .dac_nids = alc662_dac_nids,
17037                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17038                 .channel_mode = alc662_3ST_2ch_modes,
17039                 .unsol_event = alc663_m51va_unsol_event,
17040                 .init_hook = alc663_m51va_inithook,
17041         },
17042         [ALC663_ASUS_G50V] = {
17043                 .mixers = { alc663_g50v_mixer },
17044                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17045                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17046                 .dac_nids = alc662_dac_nids,
17047                 .dig_out_nid = ALC662_DIGOUT_NID,
17048                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17049                 .channel_mode = alc662_3ST_6ch_modes,
17050                 .input_mux = &alc663_capture_source,
17051                 .unsol_event = alc663_g50v_unsol_event,
17052                 .setup = alc663_g50v_setup,
17053                 .init_hook = alc663_g50v_inithook,
17054         },
17055         [ALC663_ASUS_MODE1] = {
17056                 .mixers = { alc663_m51va_mixer },
17057                 .cap_mixer = alc662_auto_capture_mixer,
17058                 .init_verbs = { alc662_init_verbs,
17059                                 alc663_21jd_amic_init_verbs },
17060                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17061                 .hp_nid = 0x03,
17062                 .dac_nids = alc662_dac_nids,
17063                 .dig_out_nid = ALC662_DIGOUT_NID,
17064                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17065                 .channel_mode = alc662_3ST_2ch_modes,
17066                 .unsol_event = alc663_mode1_unsol_event,
17067                 .setup = alc663_mode1_setup,
17068                 .init_hook = alc663_mode1_inithook,
17069         },
17070         [ALC662_ASUS_MODE2] = {
17071                 .mixers = { alc662_1bjd_mixer },
17072                 .cap_mixer = alc662_auto_capture_mixer,
17073                 .init_verbs = { alc662_init_verbs,
17074                                 alc662_1bjd_amic_init_verbs },
17075                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17076                 .dac_nids = alc662_dac_nids,
17077                 .dig_out_nid = ALC662_DIGOUT_NID,
17078                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17079                 .channel_mode = alc662_3ST_2ch_modes,
17080                 .unsol_event = alc662_mode2_unsol_event,
17081                 .setup = alc662_mode2_setup,
17082                 .init_hook = alc662_mode2_inithook,
17083         },
17084         [ALC663_ASUS_MODE3] = {
17085                 .mixers = { alc663_two_hp_m1_mixer },
17086                 .cap_mixer = alc662_auto_capture_mixer,
17087                 .init_verbs = { alc662_init_verbs,
17088                                 alc663_two_hp_amic_m1_init_verbs },
17089                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17090                 .hp_nid = 0x03,
17091                 .dac_nids = alc662_dac_nids,
17092                 .dig_out_nid = ALC662_DIGOUT_NID,
17093                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17094                 .channel_mode = alc662_3ST_2ch_modes,
17095                 .unsol_event = alc663_mode3_unsol_event,
17096                 .setup = alc663_mode3_setup,
17097                 .init_hook = alc663_mode3_inithook,
17098         },
17099         [ALC663_ASUS_MODE4] = {
17100                 .mixers = { alc663_asus_21jd_clfe_mixer },
17101                 .cap_mixer = alc662_auto_capture_mixer,
17102                 .init_verbs = { alc662_init_verbs,
17103                                 alc663_21jd_amic_init_verbs},
17104                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17105                 .hp_nid = 0x03,
17106                 .dac_nids = alc662_dac_nids,
17107                 .dig_out_nid = ALC662_DIGOUT_NID,
17108                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17109                 .channel_mode = alc662_3ST_2ch_modes,
17110                 .unsol_event = alc663_mode4_unsol_event,
17111                 .setup = alc663_mode4_setup,
17112                 .init_hook = alc663_mode4_inithook,
17113         },
17114         [ALC663_ASUS_MODE5] = {
17115                 .mixers = { alc663_asus_15jd_clfe_mixer },
17116                 .cap_mixer = alc662_auto_capture_mixer,
17117                 .init_verbs = { alc662_init_verbs,
17118                                 alc663_15jd_amic_init_verbs },
17119                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17120                 .hp_nid = 0x03,
17121                 .dac_nids = alc662_dac_nids,
17122                 .dig_out_nid = ALC662_DIGOUT_NID,
17123                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17124                 .channel_mode = alc662_3ST_2ch_modes,
17125                 .unsol_event = alc663_mode5_unsol_event,
17126                 .setup = alc663_mode5_setup,
17127                 .init_hook = alc663_mode5_inithook,
17128         },
17129         [ALC663_ASUS_MODE6] = {
17130                 .mixers = { alc663_two_hp_m2_mixer },
17131                 .cap_mixer = alc662_auto_capture_mixer,
17132                 .init_verbs = { alc662_init_verbs,
17133                                 alc663_two_hp_amic_m2_init_verbs },
17134                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17135                 .hp_nid = 0x03,
17136                 .dac_nids = alc662_dac_nids,
17137                 .dig_out_nid = ALC662_DIGOUT_NID,
17138                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17139                 .channel_mode = alc662_3ST_2ch_modes,
17140                 .unsol_event = alc663_mode6_unsol_event,
17141                 .setup = alc663_mode6_setup,
17142                 .init_hook = alc663_mode6_inithook,
17143         },
17144         [ALC272_DELL] = {
17145                 .mixers = { alc663_m51va_mixer },
17146                 .cap_mixer = alc272_auto_capture_mixer,
17147                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
17148                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17149                 .dac_nids = alc662_dac_nids,
17150                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17151                 .adc_nids = alc272_adc_nids,
17152                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
17153                 .capsrc_nids = alc272_capsrc_nids,
17154                 .channel_mode = alc662_3ST_2ch_modes,
17155                 .unsol_event = alc663_m51va_unsol_event,
17156                 .setup = alc663_m51va_setup,
17157                 .init_hook = alc663_m51va_inithook,
17158         },
17159         [ALC272_DELL_ZM1] = {
17160                 .mixers = { alc663_m51va_mixer },
17161                 .cap_mixer = alc662_auto_capture_mixer,
17162                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
17163                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17164                 .dac_nids = alc662_dac_nids,
17165                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17166                 .adc_nids = alc662_adc_nids,
17167                 .num_adc_nids = 1,
17168                 .capsrc_nids = alc662_capsrc_nids,
17169                 .channel_mode = alc662_3ST_2ch_modes,
17170                 .unsol_event = alc663_m51va_unsol_event,
17171                 .setup = alc663_m51va_setup,
17172                 .init_hook = alc663_m51va_inithook,
17173         },
17174         [ALC272_SAMSUNG_NC10] = {
17175                 .mixers = { alc272_nc10_mixer },
17176                 .init_verbs = { alc662_init_verbs,
17177                                 alc663_21jd_amic_init_verbs },
17178                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
17179                 .dac_nids = alc272_dac_nids,
17180                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17181                 .channel_mode = alc662_3ST_2ch_modes,
17182                 /*.input_mux = &alc272_nc10_capture_source,*/
17183                 .unsol_event = alc663_mode4_unsol_event,
17184                 .setup = alc663_mode4_setup,
17185                 .init_hook = alc663_mode4_inithook,
17186         },
17187 };
17188
17189
17190 /*
17191  * BIOS auto configuration
17192  */
17193
17194 /* convert from MIX nid to DAC */
17195 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
17196 {
17197         if (nid == 0x0f)
17198                 return 0x02;
17199         else if (nid >= 0x0c && nid <= 0x0e)
17200                 return nid - 0x0c + 0x02;
17201         else
17202                 return 0;
17203 }
17204
17205 /* get MIX nid connected to the given pin targeted to DAC */
17206 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
17207                                    hda_nid_t dac)
17208 {
17209         hda_nid_t mix[4];
17210         int i, num;
17211
17212         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
17213         for (i = 0; i < num; i++) {
17214                 if (alc662_mix_to_dac(mix[i]) == dac)
17215                         return mix[i];
17216         }
17217         return 0;
17218 }
17219
17220 /* look for an empty DAC slot */
17221 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
17222 {
17223         struct alc_spec *spec = codec->spec;
17224         hda_nid_t srcs[5];
17225         int i, j, num;
17226
17227         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
17228         if (num < 0)
17229                 return 0;
17230         for (i = 0; i < num; i++) {
17231                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
17232                 if (!nid)
17233                         continue;
17234                 for (j = 0; j < spec->multiout.num_dacs; j++)
17235                         if (spec->multiout.dac_nids[j] == nid)
17236                                 break;
17237                 if (j >= spec->multiout.num_dacs)
17238                         return nid;
17239         }
17240         return 0;
17241 }
17242
17243 /* fill in the dac_nids table from the parsed pin configuration */
17244 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
17245                                      const struct auto_pin_cfg *cfg)
17246 {
17247         struct alc_spec *spec = codec->spec;
17248         int i;
17249         hda_nid_t dac;
17250
17251         spec->multiout.dac_nids = spec->private_dac_nids;
17252         for (i = 0; i < cfg->line_outs; i++) {
17253                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
17254                 if (!dac)
17255                         continue;
17256                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
17257         }
17258         return 0;
17259 }
17260
17261 static int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
17262                               hda_nid_t nid, unsigned int chs)
17263 {
17264         char name[32];
17265         sprintf(name, "%s Playback Volume", pfx);
17266         return add_control(spec, ALC_CTL_WIDGET_VOL, name,
17267                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
17268 }
17269
17270 static int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
17271                              hda_nid_t nid, unsigned int chs)
17272 {
17273         char name[32];
17274         sprintf(name, "%s Playback Switch", pfx);
17275         return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17276                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
17277 }
17278
17279 #define alc662_add_stereo_vol(spec, pfx, nid) \
17280         alc662_add_vol_ctl(spec, pfx, nid, 3)
17281 #define alc662_add_stereo_sw(spec, pfx, nid) \
17282         alc662_add_sw_ctl(spec, pfx, nid, 3)
17283
17284 /* add playback controls from the parsed DAC table */
17285 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
17286                                              const struct auto_pin_cfg *cfg)
17287 {
17288         struct alc_spec *spec = codec->spec;
17289         static const char *chname[4] = {
17290                 "Front", "Surround", NULL /*CLFE*/, "Side"
17291         };
17292         hda_nid_t nid, mix;
17293         int i, err;
17294
17295         for (i = 0; i < cfg->line_outs; i++) {
17296                 nid = spec->multiout.dac_nids[i];
17297                 if (!nid)
17298                         continue;
17299                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
17300                 if (!mix)
17301                         continue;
17302                 if (i == 2) {
17303                         /* Center/LFE */
17304                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
17305                         if (err < 0)
17306                                 return err;
17307                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
17308                         if (err < 0)
17309                                 return err;
17310                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
17311                         if (err < 0)
17312                                 return err;
17313                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
17314                         if (err < 0)
17315                                 return err;
17316                 } else {
17317                         const char *pfx;
17318                         if (cfg->line_outs == 1 &&
17319                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
17320                                 if (cfg->hp_outs)
17321                                         pfx = "Speaker";
17322                                 else
17323                                         pfx = "PCM";
17324                         } else
17325                                 pfx = chname[i];
17326                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17327                         if (err < 0)
17328                                 return err;
17329                         if (cfg->line_outs == 1 &&
17330                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
17331                                 pfx = "Speaker";
17332                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17333                         if (err < 0)
17334                                 return err;
17335                 }
17336         }
17337         return 0;
17338 }
17339
17340 /* add playback controls for speaker and HP outputs */
17341 /* return DAC nid if any new DAC is assigned */
17342 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
17343                                         const char *pfx)
17344 {
17345         struct alc_spec *spec = codec->spec;
17346         hda_nid_t nid, mix;
17347         int err;
17348
17349         if (!pin)
17350                 return 0;
17351         nid = alc662_look_for_dac(codec, pin);
17352         if (!nid) {
17353                 char name[32];
17354                 /* the corresponding DAC is already occupied */
17355                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
17356                         return 0; /* no way */
17357                 /* create a switch only */
17358                 sprintf(name, "%s Playback Switch", pfx);
17359                 return add_control(spec, ALC_CTL_WIDGET_MUTE, name,
17360                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
17361         }
17362
17363         mix = alc662_dac_to_mix(codec, pin, nid);
17364         if (!mix)
17365                 return 0;
17366         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
17367         if (err < 0)
17368                 return err;
17369         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
17370         if (err < 0)
17371                 return err;
17372         return nid;
17373 }
17374
17375 /* create playback/capture controls for input pins */
17376 #define alc662_auto_create_input_ctls \
17377         alc880_auto_create_input_ctls
17378
17379 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
17380                                               hda_nid_t nid, int pin_type,
17381                                               hda_nid_t dac)
17382 {
17383         int i, num;
17384         hda_nid_t srcs[4];
17385
17386         alc_set_pin_output(codec, nid, pin_type);
17387         /* need the manual connection? */
17388         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
17389         if (num <= 1)
17390                 return;
17391         for (i = 0; i < num; i++) {
17392                 if (alc662_mix_to_dac(srcs[i]) != dac)
17393                         continue;
17394                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
17395                 return;
17396         }
17397 }
17398
17399 static void alc662_auto_init_multi_out(struct hda_codec *codec)
17400 {
17401         struct alc_spec *spec = codec->spec;
17402         int pin_type = get_pin_type(spec->autocfg.line_out_type);
17403         int i;
17404
17405         for (i = 0; i <= HDA_SIDE; i++) {
17406                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
17407                 if (nid)
17408                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
17409                                         spec->multiout.dac_nids[i]);
17410         }
17411 }
17412
17413 static void alc662_auto_init_hp_out(struct hda_codec *codec)
17414 {
17415         struct alc_spec *spec = codec->spec;
17416         hda_nid_t pin;
17417
17418         pin = spec->autocfg.hp_pins[0];
17419         if (pin)
17420                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
17421                                                   spec->multiout.hp_nid);
17422         pin = spec->autocfg.speaker_pins[0];
17423         if (pin)
17424                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
17425                                         spec->multiout.extra_out_nid[0]);
17426 }
17427
17428 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
17429
17430 static void alc662_auto_init_analog_input(struct hda_codec *codec)
17431 {
17432         struct alc_spec *spec = codec->spec;
17433         int i;
17434
17435         for (i = 0; i < AUTO_PIN_LAST; i++) {
17436                 hda_nid_t nid = spec->autocfg.input_pins[i];
17437                 if (alc_is_input_pin(codec, nid)) {
17438                         alc_set_input_pin(codec, nid, i);
17439                         if (nid != ALC662_PIN_CD_NID &&
17440                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
17441                                 snd_hda_codec_write(codec, nid, 0,
17442                                                     AC_VERB_SET_AMP_GAIN_MUTE,
17443                                                     AMP_OUT_MUTE);
17444                 }
17445         }
17446 }
17447
17448 #define alc662_auto_init_input_src      alc882_auto_init_input_src
17449
17450 static int alc662_parse_auto_config(struct hda_codec *codec)
17451 {
17452         struct alc_spec *spec = codec->spec;
17453         int err;
17454         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
17455
17456         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
17457                                            alc662_ignore);
17458         if (err < 0)
17459                 return err;
17460         if (!spec->autocfg.line_outs)
17461                 return 0; /* can't find valid BIOS pin config */
17462
17463         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
17464         if (err < 0)
17465                 return err;
17466         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
17467         if (err < 0)
17468                 return err;
17469         err = alc662_auto_create_extra_out(codec,
17470                                            spec->autocfg.speaker_pins[0],
17471                                            "Speaker");
17472         if (err < 0)
17473                 return err;
17474         if (err)
17475                 spec->multiout.extra_out_nid[0] = err;
17476         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
17477                                            "Headphone");
17478         if (err < 0)
17479                 return err;
17480         if (err)
17481                 spec->multiout.hp_nid = err;
17482         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
17483         if (err < 0)
17484                 return err;
17485
17486         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
17487
17488         if (spec->autocfg.dig_outs)
17489                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
17490
17491         if (spec->kctls.list)
17492                 add_mixer(spec, spec->kctls.list);
17493
17494         spec->num_mux_defs = 1;
17495         spec->input_mux = &spec->private_imux[0];
17496
17497         add_verb(spec, alc662_auto_init_verbs);
17498         if (codec->vendor_id == 0x10ec0663)
17499                 add_verb(spec, alc663_auto_init_verbs);
17500
17501         err = alc_auto_add_mic_boost(codec);
17502         if (err < 0)
17503                 return err;
17504
17505         alc_ssid_check(codec, 0x15, 0x1b, 0x14);
17506
17507         return 1;
17508 }
17509
17510 /* additional initialization for auto-configuration model */
17511 static void alc662_auto_init(struct hda_codec *codec)
17512 {
17513         struct alc_spec *spec = codec->spec;
17514         alc662_auto_init_multi_out(codec);
17515         alc662_auto_init_hp_out(codec);
17516         alc662_auto_init_analog_input(codec);
17517         alc662_auto_init_input_src(codec);
17518         if (spec->unsol_event)
17519                 alc_inithook(codec);
17520 }
17521
17522 static int patch_alc662(struct hda_codec *codec)
17523 {
17524         struct alc_spec *spec;
17525         int err, board_config;
17526
17527         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
17528         if (!spec)
17529                 return -ENOMEM;
17530
17531         codec->spec = spec;
17532
17533         alc_fix_pll_init(codec, 0x20, 0x04, 15);
17534
17535         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
17536                                                   alc662_models,
17537                                                   alc662_cfg_tbl);
17538         if (board_config < 0) {
17539                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
17540                        codec->chip_name);
17541                 board_config = ALC662_AUTO;
17542         }
17543
17544         if (board_config == ALC662_AUTO) {
17545                 /* automatic parse from the BIOS config */
17546                 err = alc662_parse_auto_config(codec);
17547                 if (err < 0) {
17548                         alc_free(codec);
17549                         return err;
17550                 } else if (!err) {
17551                         printk(KERN_INFO
17552                                "hda_codec: Cannot set up configuration "
17553                                "from BIOS.  Using base mode...\n");
17554                         board_config = ALC662_3ST_2ch_DIG;
17555                 }
17556         }
17557
17558         err = snd_hda_attach_beep_device(codec, 0x1);
17559         if (err < 0) {
17560                 alc_free(codec);
17561                 return err;
17562         }
17563
17564         if (board_config != ALC662_AUTO)
17565                 setup_preset(codec, &alc662_presets[board_config]);
17566
17567         spec->stream_analog_playback = &alc662_pcm_analog_playback;
17568         spec->stream_analog_capture = &alc662_pcm_analog_capture;
17569
17570         spec->stream_digital_playback = &alc662_pcm_digital_playback;
17571         spec->stream_digital_capture = &alc662_pcm_digital_capture;
17572
17573         if (!spec->adc_nids) {
17574                 spec->adc_nids = alc662_adc_nids;
17575                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
17576         }
17577         if (!spec->capsrc_nids)
17578                 spec->capsrc_nids = alc662_capsrc_nids;
17579
17580         if (!spec->cap_mixer)
17581                 set_capture_mixer(codec);
17582         if (codec->vendor_id == 0x10ec0662)
17583                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
17584         else
17585                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
17586
17587         spec->vmaster_nid = 0x02;
17588
17589         codec->patch_ops = alc_patch_ops;
17590         if (board_config == ALC662_AUTO)
17591                 spec->init_hook = alc662_auto_init;
17592 #ifdef CONFIG_SND_HDA_POWER_SAVE
17593         if (!spec->loopback.amplist)
17594                 spec->loopback.amplist = alc662_loopbacks;
17595 #endif
17596         codec->proc_widget_hook = print_realtek_coef;
17597
17598         return 0;
17599 }
17600
17601 /*
17602  * patch entries
17603  */
17604 static struct hda_codec_preset snd_hda_preset_realtek[] = {
17605         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
17606         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
17607         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
17608         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
17609         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
17610         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
17611         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
17612           .patch = patch_alc861 },
17613         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
17614         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
17615         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
17616         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
17617           .patch = patch_alc882 },
17618         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
17619           .patch = patch_alc662 },
17620         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
17621         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
17622         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
17623         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
17624         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
17625           .patch = patch_alc882 },
17626         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
17627           .patch = patch_alc882 },
17628         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
17629         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
17630         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
17631           .patch = patch_alc882 },
17632         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc882 },
17633         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
17634         {} /* terminator */
17635 };
17636
17637 MODULE_ALIAS("snd-hda-codec-id:10ec*");
17638
17639 MODULE_LICENSE("GPL");
17640 MODULE_DESCRIPTION("Realtek HD-audio codec");
17641
17642 static struct hda_codec_preset_list realtek_list = {
17643         .preset = snd_hda_preset_realtek,
17644         .owner = THIS_MODULE,
17645 };
17646
17647 static int __init patch_realtek_init(void)
17648 {
17649         return snd_hda_add_codec_preset(&realtek_list);
17650 }
17651
17652 static void __exit patch_realtek_exit(void)
17653 {
17654         snd_hda_delete_codec_preset(&realtek_list);
17655 }
17656
17657 module_init(patch_realtek_init)
17658 module_exit(patch_realtek_exit)