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_AMIC,
 135         ALC269_DMIC,
 136         ALC269VB_AMIC,
 137         ALC269VB_DMIC,
 138         ALC269_FUJITSU,
 139         ALC269_LIFEBOOK,
 140         ALC269_AUTO,
 141         ALC269_MODEL_LAST /* last tag */
 142 };
 143
 144 /* ALC861 models */
 145 enum {
 146         ALC861_3ST,
 147         ALC660_3ST,
 148         ALC861_3ST_DIG,
 149         ALC861_6ST_DIG,
 150         ALC861_UNIWILL_M31,
 151         ALC861_TOSHIBA,
 152         ALC861_ASUS,
 153         ALC861_ASUS_LAPTOP,
 154         ALC861_AUTO,
 155         ALC861_MODEL_LAST,
 156 };
 157
 158 /* ALC861-VD models */
 159 enum {
 160         ALC660VD_3ST,
 161         ALC660VD_3ST_DIG,
 162         ALC660VD_ASUS_V1S,
 163         ALC861VD_3ST,
 164         ALC861VD_3ST_DIG,
 165         ALC861VD_6ST_DIG,
 166         ALC861VD_LENOVO,
 167         ALC861VD_DALLAS,
 168         ALC861VD_HP,
 169         ALC861VD_AUTO,
 170         ALC861VD_MODEL_LAST,
 171 };
 172
 173 /* ALC662 models */
 174 enum {
 175         ALC662_3ST_2ch_DIG,
 176         ALC662_3ST_6ch_DIG,
 177         ALC662_3ST_6ch,
 178         ALC662_5ST_DIG,
 179         ALC662_LENOVO_101E,
 180         ALC662_ASUS_EEEPC_P701,
 181         ALC662_ASUS_EEEPC_EP20,
 182         ALC663_ASUS_M51VA,
 183         ALC663_ASUS_G71V,
 184         ALC663_ASUS_H13,
 185         ALC663_ASUS_G50V,
 186         ALC662_ECS,
 187         ALC663_ASUS_MODE1,
 188         ALC662_ASUS_MODE2,
 189         ALC663_ASUS_MODE3,
 190         ALC663_ASUS_MODE4,
 191         ALC663_ASUS_MODE5,
 192         ALC663_ASUS_MODE6,
 193         ALC663_ASUS_MODE7,
 194         ALC663_ASUS_MODE8,
 195         ALC272_DELL,
 196         ALC272_DELL_ZM1,
 197         ALC272_SAMSUNG_NC10,
 198         ALC662_AUTO,
 199         ALC662_MODEL_LAST,
 200 };
 201
 202 /* ALC882 models */
 203 enum {
 204         ALC882_3ST_DIG,
 205         ALC882_6ST_DIG,
 206         ALC882_ARIMA,
 207         ALC882_W2JC,
 208         ALC882_TARGA,
 209         ALC882_ASUS_A7J,
 210         ALC882_ASUS_A7M,
 211         ALC885_MACPRO,
 212         ALC885_MBA21,
 213         ALC885_MBP3,
 214         ALC885_MB5,
 215         ALC885_MACMINI3,
 216         ALC885_IMAC24,
 217         ALC885_IMAC91,
 218         ALC883_3ST_2ch_DIG,
 219         ALC883_3ST_6ch_DIG,
 220         ALC883_3ST_6ch,
 221         ALC883_6ST_DIG,
 222         ALC883_TARGA_DIG,
 223         ALC883_TARGA_2ch_DIG,
 224         ALC883_TARGA_8ch_DIG,
 225         ALC883_ACER,
 226         ALC883_ACER_ASPIRE,
 227         ALC888_ACER_ASPIRE_4930G,
 228         ALC888_ACER_ASPIRE_6530G,
 229         ALC888_ACER_ASPIRE_8930G,
 230         ALC888_ACER_ASPIRE_7730G,
 231         ALC883_MEDION,
 232         ALC883_MEDION_MD2,
 233         ALC883_MEDION_WIM2160,
 234         ALC883_LAPTOP_EAPD,
 235         ALC883_LENOVO_101E_2ch,
 236         ALC883_LENOVO_NB0763,
 237         ALC888_LENOVO_MS7195_DIG,
 238         ALC888_LENOVO_SKY,
 239         ALC883_HAIER_W66,
 240         ALC888_3ST_HP,
 241         ALC888_6ST_DELL,
 242         ALC883_MITAC,
 243         ALC883_CLEVO_M540R,
 244         ALC883_CLEVO_M720,
 245         ALC883_FUJITSU_PI2515,
 246         ALC888_FUJITSU_XA3530,
 247         ALC883_3ST_6ch_INTEL,
 248         ALC889A_INTEL,
 249         ALC889_INTEL,
 250         ALC888_ASUS_M90V,
 251         ALC888_ASUS_EEE1601,
 252         ALC889A_MB31,
 253         ALC1200_ASUS_P5Q,
 254         ALC883_SONY_VAIO_TT,
 255         ALC882_AUTO,
 256         ALC882_MODEL_LAST,
 257 };
 258
 259 /* for GPIO Poll */
 260 #define GPIO_MASK       0x03
 261
 262 /* extra amp-initialization sequence types */
 263 enum {
 264         ALC_INIT_NONE,
 265         ALC_INIT_DEFAULT,
 266         ALC_INIT_GPIO1,
 267         ALC_INIT_GPIO2,
 268         ALC_INIT_GPIO3,
 269 };
 270
 271 struct alc_mic_route {
 272         hda_nid_t pin;
 273         unsigned char mux_idx;
 274         unsigned char amix_idx;
 275 };
 276
 277 #define MUX_IDX_UNDEF   ((unsigned char)-1)
 278
 279 struct alc_spec {
 280         /* codec parameterization */
 281         struct snd_kcontrol_new *mixers[5];     /* mixer arrays */
 282         unsigned int num_mixers;
 283         struct snd_kcontrol_new *cap_mixer;     /* capture mixer */
 284         unsigned int beep_amp;  /* beep amp value, set via set_beep_amp() */
 285
 286         const struct hda_verb *init_verbs[10];  /* initialization verbs
 287                                                  * don't forget NULL
 288                                                  * termination!
 289                                                  */
 290         unsigned int num_init_verbs;
 291
 292         char stream_name_analog[32];    /* analog PCM stream */
 293         struct hda_pcm_stream *stream_analog_playback;
 294         struct hda_pcm_stream *stream_analog_capture;
 295         struct hda_pcm_stream *stream_analog_alt_playback;
 296         struct hda_pcm_stream *stream_analog_alt_capture;
 297
 298         char stream_name_digital[32];   /* digital PCM stream */
 299         struct hda_pcm_stream *stream_digital_playback;
 300         struct hda_pcm_stream *stream_digital_capture;
 301
 302         /* playback */
 303         struct hda_multi_out multiout;  /* playback set-up
 304                                          * max_channels, dacs must be set
 305                                          * dig_out_nid and hp_nid are optional
 306                                          */
 307         hda_nid_t alt_dac_nid;
 308         hda_nid_t slave_dig_outs[3];    /* optional - for auto-parsing */
 309         int dig_out_type;
 310
 311         /* capture */
 312         unsigned int num_adc_nids;
 313         hda_nid_t *adc_nids;
 314         hda_nid_t *capsrc_nids;
 315         hda_nid_t dig_in_nid;           /* digital-in NID; optional */
 316
 317         /* capture source */
 318         unsigned int num_mux_defs;
 319         const struct hda_input_mux *input_mux;
 320         unsigned int cur_mux[3];
 321         struct alc_mic_route ext_mic;
 322         struct alc_mic_route int_mic;
 323
 324         /* channel model */
 325         const struct hda_channel_mode *channel_mode;
 326         int num_channel_mode;
 327         int need_dac_fix;
 328         int const_channel_count;
 329         int ext_channel_count;
 330
 331         /* PCM information */
 332         struct hda_pcm pcm_rec[3];      /* used in alc_build_pcms() */
 333
 334         /* dynamic controls, init_verbs and input_mux */
 335         struct auto_pin_cfg autocfg;
 336         struct snd_array kctls;
 337         struct hda_input_mux private_imux[3];
 338         hda_nid_t private_dac_nids[AUTO_CFG_MAX_OUTS];
 339         hda_nid_t private_adc_nids[AUTO_CFG_MAX_OUTS];
 340         hda_nid_t private_capsrc_nids[AUTO_CFG_MAX_OUTS];
 341
 342         /* hooks */
 343         void (*init_hook)(struct hda_codec *codec);
 344         void (*unsol_event)(struct hda_codec *codec, unsigned int res);
 345 #ifdef CONFIG_SND_HDA_POWER_SAVE
 346         void (*power_hook)(struct hda_codec *codec);
 347 #endif
 348
 349         /* for pin sensing */
 350         unsigned int sense_updated: 1;
 351         unsigned int jack_present: 1;
 352         unsigned int master_sw: 1;
 353         unsigned int auto_mic:1;
 354
 355         /* other flags */
 356         unsigned int no_analog :1; /* digital I/O only */
 357         int init_amp;
 358
 359         /* for virtual master */
 360         hda_nid_t vmaster_nid;
 361 #ifdef CONFIG_SND_HDA_POWER_SAVE
 362         struct hda_loopback_check loopback;
 363 #endif
 364
 365         /* for PLL fix */
 366         hda_nid_t pll_nid;
 367         unsigned int pll_coef_idx, pll_coef_bit;
 368 };
 369
 370 /*
 371  * configuration template - to be copied to the spec instance
 372  */
 373 struct alc_config_preset {
 374         struct snd_kcontrol_new *mixers[5]; /* should be identical size
 375                                              * with spec
 376                                              */
 377         struct snd_kcontrol_new *cap_mixer; /* capture mixer */
 378         const struct hda_verb *init_verbs[5];
 379         unsigned int num_dacs;
 380         hda_nid_t *dac_nids;
 381         hda_nid_t dig_out_nid;          /* optional */
 382         hda_nid_t hp_nid;               /* optional */
 383         hda_nid_t *slave_dig_outs;
 384         unsigned int num_adc_nids;
 385         hda_nid_t *adc_nids;
 386         hda_nid_t *capsrc_nids;
 387         hda_nid_t dig_in_nid;
 388         unsigned int num_channel_mode;
 389         const struct hda_channel_mode *channel_mode;
 390         int need_dac_fix;
 391         int const_channel_count;
 392         unsigned int num_mux_defs;
 393         const struct hda_input_mux *input_mux;
 394         void (*unsol_event)(struct hda_codec *, unsigned int);
 395         void (*setup)(struct hda_codec *);
 396         void (*init_hook)(struct hda_codec *);
 397 #ifdef CONFIG_SND_HDA_POWER_SAVE
 398         struct hda_amp_list *loopbacks;
 399         void (*power_hook)(struct hda_codec *codec);
 400 #endif
 401 };
 402
 403
 404 /*
 405  * input MUX handling
 406  */
 407 static int alc_mux_enum_info(struct snd_kcontrol *kcontrol,
 408                              struct snd_ctl_elem_info *uinfo)
 409 {
 410         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 411         struct alc_spec *spec = codec->spec;
 412         unsigned int mux_idx = snd_ctl_get_ioffidx(kcontrol, &uinfo->id);
 413         if (mux_idx >= spec->num_mux_defs)
 414                 mux_idx = 0;
 415         if (!spec->input_mux[mux_idx].num_items && mux_idx > 0)
 416                 mux_idx = 0;
 417         return snd_hda_input_mux_info(&spec->input_mux[mux_idx], uinfo);
 418 }
 419
 420 static int alc_mux_enum_get(struct snd_kcontrol *kcontrol,
 421                             struct snd_ctl_elem_value *ucontrol)
 422 {
 423         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 424         struct alc_spec *spec = codec->spec;
 425         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 426
 427         ucontrol->value.enumerated.item[0] = spec->cur_mux[adc_idx];
 428         return 0;
 429 }
 430
 431 static int alc_mux_enum_put(struct snd_kcontrol *kcontrol,
 432                             struct snd_ctl_elem_value *ucontrol)
 433 {
 434         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 435         struct alc_spec *spec = codec->spec;
 436         const struct hda_input_mux *imux;
 437         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
 438         unsigned int mux_idx;
 439         hda_nid_t nid = spec->capsrc_nids ?
 440                 spec->capsrc_nids[adc_idx] : spec->adc_nids[adc_idx];
 441         unsigned int type;
 442
 443         mux_idx = adc_idx >= spec->num_mux_defs ? 0 : adc_idx;
 444         imux = &spec->input_mux[mux_idx];
 445         if (!imux->num_items && mux_idx > 0)
 446                 imux = &spec->input_mux[0];
 447
 448         type = get_wcaps_type(get_wcaps(codec, nid));
 449         if (type == AC_WID_AUD_MIX) {
 450                 /* Matrix-mixer style (e.g. ALC882) */
 451                 unsigned int *cur_val = &spec->cur_mux[adc_idx];
 452                 unsigned int i, idx;
 453
 454                 idx = ucontrol->value.enumerated.item[0];
 455                 if (idx >= imux->num_items)
 456                         idx = imux->num_items - 1;
 457                 if (*cur_val == idx)
 458                         return 0;
 459                 for (i = 0; i < imux->num_items; i++) {
 460                         unsigned int v = (i == idx) ? 0 : HDA_AMP_MUTE;
 461                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT,
 462                                                  imux->items[i].index,
 463                                                  HDA_AMP_MUTE, v);
 464                 }
 465                 *cur_val = idx;
 466                 return 1;
 467         } else {
 468                 /* MUX style (e.g. ALC880) */
 469                 return snd_hda_input_mux_put(codec, imux, ucontrol, nid,
 470                                              &spec->cur_mux[adc_idx]);
 471         }
 472 }
 473
 474 /*
 475  * channel mode setting
 476  */
 477 static int alc_ch_mode_info(struct snd_kcontrol *kcontrol,
 478                             struct snd_ctl_elem_info *uinfo)
 479 {
 480         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 481         struct alc_spec *spec = codec->spec;
 482         return snd_hda_ch_mode_info(codec, uinfo, spec->channel_mode,
 483                                     spec->num_channel_mode);
 484 }
 485
 486 static int alc_ch_mode_get(struct snd_kcontrol *kcontrol,
 487                            struct snd_ctl_elem_value *ucontrol)
 488 {
 489         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 490         struct alc_spec *spec = codec->spec;
 491         return snd_hda_ch_mode_get(codec, ucontrol, spec->channel_mode,
 492                                    spec->num_channel_mode,
 493                                    spec->ext_channel_count);
 494 }
 495
 496 static int alc_ch_mode_put(struct snd_kcontrol *kcontrol,
 497                            struct snd_ctl_elem_value *ucontrol)
 498 {
 499         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 500         struct alc_spec *spec = codec->spec;
 501         int err = snd_hda_ch_mode_put(codec, ucontrol, spec->channel_mode,
 502                                       spec->num_channel_mode,
 503                                       &spec->ext_channel_count);
 504         if (err >= 0 && !spec->const_channel_count) {
 505                 spec->multiout.max_channels = spec->ext_channel_count;
 506                 if (spec->need_dac_fix)
 507                         spec->multiout.num_dacs = spec->multiout.max_channels / 2;
 508         }
 509         return err;
 510 }
 511
 512 /*
 513  * Control the mode of pin widget settings via the mixer.  "pc" is used
 514  * instead of "%" to avoid consequences of accidently treating the % as
 515  * being part of a format specifier.  Maximum allowed length of a value is
 516  * 63 characters plus NULL terminator.
 517  *
 518  * Note: some retasking pin complexes seem to ignore requests for input
 519  * states other than HiZ (eg: PIN_VREFxx) and revert to HiZ if any of these
 520  * are requested.  Therefore order this list so that this behaviour will not
 521  * cause problems when mixer clients move through the enum sequentially.
 522  * NIDs 0x0f and 0x10 have been observed to have this behaviour as of
 523  * March 2006.
 524  */
 525 static char *alc_pin_mode_names[] = {
 526         "Mic 50pc bias", "Mic 80pc bias",
 527         "Line in", "Line out", "Headphone out",
 528 };
 529 static unsigned char alc_pin_mode_values[] = {
 530         PIN_VREF50, PIN_VREF80, PIN_IN, PIN_OUT, PIN_HP,
 531 };
 532 /* The control can present all 5 options, or it can limit the options based
 533  * in the pin being assumed to be exclusively an input or an output pin.  In
 534  * addition, "input" pins may or may not process the mic bias option
 535  * depending on actual widget capability (NIDs 0x0f and 0x10 don't seem to
 536  * accept requests for bias as of chip versions up to March 2006) and/or
 537  * wiring in the computer.
 538  */
 539 #define ALC_PIN_DIR_IN              0x00
 540 #define ALC_PIN_DIR_OUT             0x01
 541 #define ALC_PIN_DIR_INOUT           0x02
 542 #define ALC_PIN_DIR_IN_NOMICBIAS    0x03
 543 #define ALC_PIN_DIR_INOUT_NOMICBIAS 0x04
 544
 545 /* Info about the pin modes supported by the different pin direction modes.
 546  * For each direction the minimum and maximum values are given.
 547  */
 548 static signed char alc_pin_mode_dir_info[5][2] = {
 549         { 0, 2 },    /* ALC_PIN_DIR_IN */
 550         { 3, 4 },    /* ALC_PIN_DIR_OUT */
 551         { 0, 4 },    /* ALC_PIN_DIR_INOUT */
 552         { 2, 2 },    /* ALC_PIN_DIR_IN_NOMICBIAS */
 553         { 2, 4 },    /* ALC_PIN_DIR_INOUT_NOMICBIAS */
 554 };
 555 #define alc_pin_mode_min(_dir) (alc_pin_mode_dir_info[_dir][0])
 556 #define alc_pin_mode_max(_dir) (alc_pin_mode_dir_info[_dir][1])
 557 #define alc_pin_mode_n_items(_dir) \
 558         (alc_pin_mode_max(_dir)-alc_pin_mode_min(_dir)+1)
 559
 560 static int alc_pin_mode_info(struct snd_kcontrol *kcontrol,
 561                              struct snd_ctl_elem_info *uinfo)
 562 {
 563         unsigned int item_num = uinfo->value.enumerated.item;
 564         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 565
 566         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 567         uinfo->count = 1;
 568         uinfo->value.enumerated.items = alc_pin_mode_n_items(dir);
 569
 570         if (item_num<alc_pin_mode_min(dir) || item_num>alc_pin_mode_max(dir))
 571                 item_num = alc_pin_mode_min(dir);
 572         strcpy(uinfo->value.enumerated.name, alc_pin_mode_names[item_num]);
 573         return 0;
 574 }
 575
 576 static int alc_pin_mode_get(struct snd_kcontrol *kcontrol,
 577                             struct snd_ctl_elem_value *ucontrol)
 578 {
 579         unsigned int i;
 580         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 581         hda_nid_t nid = kcontrol->private_value & 0xffff;
 582         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 583         long *valp = ucontrol->value.integer.value;
 584         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 585                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 586                                                  0x00);
 587
 588         /* Find enumerated value for current pinctl setting */
 589         i = alc_pin_mode_min(dir);
 590         while (i <= alc_pin_mode_max(dir) && alc_pin_mode_values[i] != pinctl)
 591                 i++;
 592         *valp = i <= alc_pin_mode_max(dir) ? i: alc_pin_mode_min(dir);
 593         return 0;
 594 }
 595
 596 static int alc_pin_mode_put(struct snd_kcontrol *kcontrol,
 597                             struct snd_ctl_elem_value *ucontrol)
 598 {
 599         signed int change;
 600         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 601         hda_nid_t nid = kcontrol->private_value & 0xffff;
 602         unsigned char dir = (kcontrol->private_value >> 16) & 0xff;
 603         long val = *ucontrol->value.integer.value;
 604         unsigned int pinctl = snd_hda_codec_read(codec, nid, 0,
 605                                                  AC_VERB_GET_PIN_WIDGET_CONTROL,
 606                                                  0x00);
 607
 608         if (val < alc_pin_mode_min(dir) || val > alc_pin_mode_max(dir))
 609                 val = alc_pin_mode_min(dir);
 610
 611         change = pinctl != alc_pin_mode_values[val];
 612         if (change) {
 613                 /* Set pin mode to that requested */
 614                 snd_hda_codec_write_cache(codec, nid, 0,
 615                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
 616                                           alc_pin_mode_values[val]);
 617
 618                 /* Also enable the retasking pin's input/output as required
 619                  * for the requested pin mode.  Enum values of 2 or less are
 620                  * input modes.
 621                  *
 622                  * Dynamically switching the input/output buffers probably
 623                  * reduces noise slightly (particularly on input) so we'll
 624                  * do it.  However, having both input and output buffers
 625                  * enabled simultaneously doesn't seem to be problematic if
 626                  * this turns out to be necessary in the future.
 627                  */
 628                 if (val <= 2) {
 629                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 630                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 631                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 632                                                  HDA_AMP_MUTE, 0);
 633                 } else {
 634                         snd_hda_codec_amp_stereo(codec, nid, HDA_INPUT, 0,
 635                                                  HDA_AMP_MUTE, HDA_AMP_MUTE);
 636                         snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
 637                                                  HDA_AMP_MUTE, 0);
 638                 }
 639         }
 640         return change;
 641 }
 642
 643 #define ALC_PIN_MODE(xname, nid, dir) \
 644         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 645           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 646           .info = alc_pin_mode_info, \
 647           .get = alc_pin_mode_get, \
 648           .put = alc_pin_mode_put, \
 649           .private_value = nid | (dir<<16) }
 650
 651 /* A switch control for ALC260 GPIO pins.  Multiple GPIOs can be ganged
 652  * together using a mask with more than one bit set.  This control is
 653  * currently used only by the ALC260 test model.  At this stage they are not
 654  * needed for any "production" models.
 655  */
 656 #ifdef CONFIG_SND_DEBUG
 657 #define alc_gpio_data_info      snd_ctl_boolean_mono_info
 658
 659 static int alc_gpio_data_get(struct snd_kcontrol *kcontrol,
 660                              struct snd_ctl_elem_value *ucontrol)
 661 {
 662         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 663         hda_nid_t nid = kcontrol->private_value & 0xffff;
 664         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 665         long *valp = ucontrol->value.integer.value;
 666         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 667                                               AC_VERB_GET_GPIO_DATA, 0x00);
 668
 669         *valp = (val & mask) != 0;
 670         return 0;
 671 }
 672 static int alc_gpio_data_put(struct snd_kcontrol *kcontrol,
 673                              struct snd_ctl_elem_value *ucontrol)
 674 {
 675         signed int change;
 676         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 677         hda_nid_t nid = kcontrol->private_value & 0xffff;
 678         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 679         long val = *ucontrol->value.integer.value;
 680         unsigned int gpio_data = snd_hda_codec_read(codec, nid, 0,
 681                                                     AC_VERB_GET_GPIO_DATA,
 682                                                     0x00);
 683
 684         /* Set/unset the masked GPIO bit(s) as needed */
 685         change = (val == 0 ? 0 : mask) != (gpio_data & mask);
 686         if (val == 0)
 687                 gpio_data &= ~mask;
 688         else
 689                 gpio_data |= mask;
 690         snd_hda_codec_write_cache(codec, nid, 0,
 691                                   AC_VERB_SET_GPIO_DATA, gpio_data);
 692
 693         return change;
 694 }
 695 #define ALC_GPIO_DATA_SWITCH(xname, nid, mask) \
 696         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 697           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 698           .info = alc_gpio_data_info, \
 699           .get = alc_gpio_data_get, \
 700           .put = alc_gpio_data_put, \
 701           .private_value = nid | (mask<<16) }
 702 #endif   /* CONFIG_SND_DEBUG */
 703
 704 /* A switch control to allow the enabling of the digital IO pins on the
 705  * ALC260.  This is incredibly simplistic; the intention of this control is
 706  * to provide something in the test model allowing digital outputs to be
 707  * identified if present.  If models are found which can utilise these
 708  * outputs a more complete mixer control can be devised for those models if
 709  * necessary.
 710  */
 711 #ifdef CONFIG_SND_DEBUG
 712 #define alc_spdif_ctrl_info     snd_ctl_boolean_mono_info
 713
 714 static int alc_spdif_ctrl_get(struct snd_kcontrol *kcontrol,
 715                               struct snd_ctl_elem_value *ucontrol)
 716 {
 717         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 718         hda_nid_t nid = kcontrol->private_value & 0xffff;
 719         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 720         long *valp = ucontrol->value.integer.value;
 721         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 722                                               AC_VERB_GET_DIGI_CONVERT_1, 0x00);
 723
 724         *valp = (val & mask) != 0;
 725         return 0;
 726 }
 727 static int alc_spdif_ctrl_put(struct snd_kcontrol *kcontrol,
 728                               struct snd_ctl_elem_value *ucontrol)
 729 {
 730         signed int change;
 731         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 732         hda_nid_t nid = kcontrol->private_value & 0xffff;
 733         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 734         long val = *ucontrol->value.integer.value;
 735         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 736                                                     AC_VERB_GET_DIGI_CONVERT_1,
 737                                                     0x00);
 738
 739         /* Set/unset the masked control bit(s) as needed */
 740         change = (val == 0 ? 0 : mask) != (ctrl_data & mask);
 741         if (val==0)
 742                 ctrl_data &= ~mask;
 743         else
 744                 ctrl_data |= mask;
 745         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_DIGI_CONVERT_1,
 746                                   ctrl_data);
 747
 748         return change;
 749 }
 750 #define ALC_SPDIF_CTRL_SWITCH(xname, nid, mask) \
 751         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 752           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 753           .info = alc_spdif_ctrl_info, \
 754           .get = alc_spdif_ctrl_get, \
 755           .put = alc_spdif_ctrl_put, \
 756           .private_value = nid | (mask<<16) }
 757 #endif   /* CONFIG_SND_DEBUG */
 758
 759 /* A switch control to allow the enabling EAPD digital outputs on the ALC26x.
 760  * Again, this is only used in the ALC26x test models to help identify when
 761  * the EAPD line must be asserted for features to work.
 762  */
 763 #ifdef CONFIG_SND_DEBUG
 764 #define alc_eapd_ctrl_info      snd_ctl_boolean_mono_info
 765
 766 static int alc_eapd_ctrl_get(struct snd_kcontrol *kcontrol,
 767                               struct snd_ctl_elem_value *ucontrol)
 768 {
 769         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 770         hda_nid_t nid = kcontrol->private_value & 0xffff;
 771         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 772         long *valp = ucontrol->value.integer.value;
 773         unsigned int val = snd_hda_codec_read(codec, nid, 0,
 774                                               AC_VERB_GET_EAPD_BTLENABLE, 0x00);
 775
 776         *valp = (val & mask) != 0;
 777         return 0;
 778 }
 779
 780 static int alc_eapd_ctrl_put(struct snd_kcontrol *kcontrol,
 781                               struct snd_ctl_elem_value *ucontrol)
 782 {
 783         int change;
 784         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
 785         hda_nid_t nid = kcontrol->private_value & 0xffff;
 786         unsigned char mask = (kcontrol->private_value >> 16) & 0xff;
 787         long val = *ucontrol->value.integer.value;
 788         unsigned int ctrl_data = snd_hda_codec_read(codec, nid, 0,
 789                                                     AC_VERB_GET_EAPD_BTLENABLE,
 790                                                     0x00);
 791
 792         /* Set/unset the masked control bit(s) as needed */
 793         change = (!val ? 0 : mask) != (ctrl_data & mask);
 794         if (!val)
 795                 ctrl_data &= ~mask;
 796         else
 797                 ctrl_data |= mask;
 798         snd_hda_codec_write_cache(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
 799                                   ctrl_data);
 800
 801         return change;
 802 }
 803
 804 #define ALC_EAPD_CTRL_SWITCH(xname, nid, mask) \
 805         { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = xname, .index = 0,  \
 806           .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
 807           .info = alc_eapd_ctrl_info, \
 808           .get = alc_eapd_ctrl_get, \
 809           .put = alc_eapd_ctrl_put, \
 810           .private_value = nid | (mask<<16) }
 811 #endif   /* CONFIG_SND_DEBUG */
 812
 813 /*
 814  * set up the input pin config (depending on the given auto-pin type)
 815  */
 816 static void alc_set_input_pin(struct hda_codec *codec, hda_nid_t nid,
 817                               int auto_pin_type)
 818 {
 819         unsigned int val = PIN_IN;
 820
 821         if (auto_pin_type <= AUTO_PIN_FRONT_MIC) {
 822                 unsigned int pincap;
 823                 pincap = snd_hda_query_pin_caps(codec, nid);
 824                 pincap = (pincap & AC_PINCAP_VREF) >> AC_PINCAP_VREF_SHIFT;
 825                 if (pincap & AC_PINCAP_VREF_80)
 826                         val = PIN_VREF80;
 827                 else if (pincap & AC_PINCAP_VREF_50)
 828                         val = PIN_VREF50;
 829                 else if (pincap & AC_PINCAP_VREF_100)
 830                         val = PIN_VREF100;
 831                 else if (pincap & AC_PINCAP_VREF_GRD)
 832                         val = PIN_VREFGRD;
 833         }
 834         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL, val);
 835 }
 836
 837 /*
 838  */
 839 static void add_mixer(struct alc_spec *spec, struct snd_kcontrol_new *mix)
 840 {
 841         if (snd_BUG_ON(spec->num_mixers >= ARRAY_SIZE(spec->mixers)))
 842                 return;
 843         spec->mixers[spec->num_mixers++] = mix;
 844 }
 845
 846 static void add_verb(struct alc_spec *spec, const struct hda_verb *verb)
 847 {
 848         if (snd_BUG_ON(spec->num_init_verbs >= ARRAY_SIZE(spec->init_verbs)))
 849                 return;
 850         spec->init_verbs[spec->num_init_verbs++] = verb;
 851 }
 852
 853 /*
 854  * set up from the preset table
 855  */
 856 static void setup_preset(struct hda_codec *codec,
 857                          const struct alc_config_preset *preset)
 858 {
 859         struct alc_spec *spec = codec->spec;
 860         int i;
 861
 862         for (i = 0; i < ARRAY_SIZE(preset->mixers) && preset->mixers[i]; i++)
 863                 add_mixer(spec, preset->mixers[i]);
 864         spec->cap_mixer = preset->cap_mixer;
 865         for (i = 0; i < ARRAY_SIZE(preset->init_verbs) && preset->init_verbs[i];
 866              i++)
 867                 add_verb(spec, preset->init_verbs[i]);
 868
 869         spec->channel_mode = preset->channel_mode;
 870         spec->num_channel_mode = preset->num_channel_mode;
 871         spec->need_dac_fix = preset->need_dac_fix;
 872         spec->const_channel_count = preset->const_channel_count;
 873
 874         if (preset->const_channel_count)
 875                 spec->multiout.max_channels = preset->const_channel_count;
 876         else
 877                 spec->multiout.max_channels = spec->channel_mode[0].channels;
 878         spec->ext_channel_count = spec->channel_mode[0].channels;
 879
 880         spec->multiout.num_dacs = preset->num_dacs;
 881         spec->multiout.dac_nids = preset->dac_nids;
 882         spec->multiout.dig_out_nid = preset->dig_out_nid;
 883         spec->multiout.slave_dig_outs = preset->slave_dig_outs;
 884         spec->multiout.hp_nid = preset->hp_nid;
 885
 886         spec->num_mux_defs = preset->num_mux_defs;
 887         if (!spec->num_mux_defs)
 888                 spec->num_mux_defs = 1;
 889         spec->input_mux = preset->input_mux;
 890
 891         spec->num_adc_nids = preset->num_adc_nids;
 892         spec->adc_nids = preset->adc_nids;
 893         spec->capsrc_nids = preset->capsrc_nids;
 894         spec->dig_in_nid = preset->dig_in_nid;
 895
 896         spec->unsol_event = preset->unsol_event;
 897         spec->init_hook = preset->init_hook;
 898 #ifdef CONFIG_SND_HDA_POWER_SAVE
 899         spec->power_hook = preset->power_hook;
 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 nid = spec->autocfg.hp_pins[0];
 965         int i;
 966
 967         if (!nid)
 968                 return;
 969         spec->jack_present = snd_hda_jack_detect(codec, nid);
 970         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
 971                 nid = spec->autocfg.speaker_pins[i];
 972                 if (!nid)
 973                         break;
 974                 snd_hda_codec_write(codec, nid, 0,
 975                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
 976                                     spec->jack_present ? 0 : PIN_OUT);
 977         }
 978 }
 979
 980 static int get_connection_index(struct hda_codec *codec, hda_nid_t mux,
 981                                 hda_nid_t nid)
 982 {
 983         hda_nid_t conn[HDA_MAX_NUM_INPUTS];
 984         int i, nums;
 985
 986         nums = snd_hda_get_connections(codec, mux, conn, ARRAY_SIZE(conn));
 987         for (i = 0; i < nums; i++)
 988                 if (conn[i] == nid)
 989                         return i;
 990         return -1;
 991 }
 992
 993 static void alc_mic_automute(struct hda_codec *codec)
 994 {
 995         struct alc_spec *spec = codec->spec;
 996         struct alc_mic_route *dead, *alive;
 997         unsigned int present, type;
 998         hda_nid_t cap_nid;
 999
1000         if (!spec->auto_mic)
1001                 return;
1002         if (!spec->int_mic.pin || !spec->ext_mic.pin)
1003                 return;
1004         if (snd_BUG_ON(!spec->adc_nids))
1005                 return;
1006
1007         cap_nid = spec->capsrc_nids ? spec->capsrc_nids[0] : spec->adc_nids[0];
1008
1009         present = snd_hda_jack_detect(codec, spec->ext_mic.pin);
1010         if (present) {
1011                 alive = &spec->ext_mic;
1012                 dead = &spec->int_mic;
1013         } else {
1014                 alive = &spec->int_mic;
1015                 dead = &spec->ext_mic;
1016         }
1017
1018         type = get_wcaps_type(get_wcaps(codec, cap_nid));
1019         if (type == AC_WID_AUD_MIX) {
1020                 /* Matrix-mixer style (e.g. ALC882) */
1021                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1022                                          alive->mux_idx,
1023                                          HDA_AMP_MUTE, 0);
1024                 snd_hda_codec_amp_stereo(codec, cap_nid, HDA_INPUT,
1025                                          dead->mux_idx,
1026                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
1027         } else {
1028                 /* MUX style (e.g. ALC880) */
1029                 snd_hda_codec_write_cache(codec, cap_nid, 0,
1030                                           AC_VERB_SET_CONNECT_SEL,
1031                                           alive->mux_idx);
1032         }
1033
1034         /* FIXME: analog mixer */
1035 }
1036
1037 /* unsolicited event for HP jack sensing */
1038 static void alc_sku_unsol_event(struct hda_codec *codec, unsigned int res)
1039 {
1040         if (codec->vendor_id == 0x10ec0880)
1041                 res >>= 28;
1042         else
1043                 res >>= 26;
1044         switch (res) {
1045         case ALC880_HP_EVENT:
1046                 alc_automute_pin(codec);
1047                 break;
1048         case ALC880_MIC_EVENT:
1049                 alc_mic_automute(codec);
1050                 break;
1051         }
1052 }
1053
1054 static void alc_inithook(struct hda_codec *codec)
1055 {
1056         alc_automute_pin(codec);
1057         alc_mic_automute(codec);
1058 }
1059
1060 /* additional initialization for ALC888 variants */
1061 static void alc888_coef_init(struct hda_codec *codec)
1062 {
1063         unsigned int tmp;
1064
1065         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 0);
1066         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1067         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1068         if ((tmp & 0xf0) == 0x20)
1069                 /* alc888S-VC */
1070                 snd_hda_codec_read(codec, 0x20, 0,
1071                                    AC_VERB_SET_PROC_COEF, 0x830);
1072          else
1073                  /* alc888-VB */
1074                  snd_hda_codec_read(codec, 0x20, 0,
1075                                     AC_VERB_SET_PROC_COEF, 0x3030);
1076 }
1077
1078 static void alc889_coef_init(struct hda_codec *codec)
1079 {
1080         unsigned int tmp;
1081
1082         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1083         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
1084         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX, 7);
1085         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_PROC_COEF, tmp|0x2010);
1086 }
1087
1088 /* turn on/off EAPD control (only if available) */
1089 static void set_eapd(struct hda_codec *codec, hda_nid_t nid, int on)
1090 {
1091         if (get_wcaps_type(get_wcaps(codec, nid)) != AC_WID_PIN)
1092                 return;
1093         if (snd_hda_query_pin_caps(codec, nid) & AC_PINCAP_EAPD)
1094                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_EAPD_BTLENABLE,
1095                                     on ? 2 : 0);
1096 }
1097
1098 static void alc_auto_init_amp(struct hda_codec *codec, int type)
1099 {
1100         unsigned int tmp;
1101
1102         switch (type) {
1103         case ALC_INIT_GPIO1:
1104                 snd_hda_sequence_write(codec, alc_gpio1_init_verbs);
1105                 break;
1106         case ALC_INIT_GPIO2:
1107                 snd_hda_sequence_write(codec, alc_gpio2_init_verbs);
1108                 break;
1109         case ALC_INIT_GPIO3:
1110                 snd_hda_sequence_write(codec, alc_gpio3_init_verbs);
1111                 break;
1112         case ALC_INIT_DEFAULT:
1113                 switch (codec->vendor_id) {
1114                 case 0x10ec0260:
1115                         set_eapd(codec, 0x0f, 1);
1116                         set_eapd(codec, 0x10, 1);
1117                         break;
1118                 case 0x10ec0262:
1119                 case 0x10ec0267:
1120                 case 0x10ec0268:
1121                 case 0x10ec0269:
1122                 case 0x10ec0270:
1123                 case 0x10ec0272:
1124                 case 0x10ec0660:
1125                 case 0x10ec0662:
1126                 case 0x10ec0663:
1127                 case 0x10ec0862:
1128                 case 0x10ec0889:
1129                         set_eapd(codec, 0x14, 1);
1130                         set_eapd(codec, 0x15, 1);
1131                         break;
1132                 }
1133                 switch (codec->vendor_id) {
1134                 case 0x10ec0260:
1135                         snd_hda_codec_write(codec, 0x1a, 0,
1136                                             AC_VERB_SET_COEF_INDEX, 7);
1137                         tmp = snd_hda_codec_read(codec, 0x1a, 0,
1138                                                  AC_VERB_GET_PROC_COEF, 0);
1139                         snd_hda_codec_write(codec, 0x1a, 0,
1140                                             AC_VERB_SET_COEF_INDEX, 7);
1141                         snd_hda_codec_write(codec, 0x1a, 0,
1142                                             AC_VERB_SET_PROC_COEF,
1143                                             tmp | 0x2010);
1144                         break;
1145                 case 0x10ec0262:
1146                 case 0x10ec0880:
1147                 case 0x10ec0882:
1148                 case 0x10ec0883:
1149                 case 0x10ec0885:
1150                 case 0x10ec0887:
1151                 case 0x10ec0889:
1152                         alc889_coef_init(codec);
1153                         break;
1154                 case 0x10ec0888:
1155                         alc888_coef_init(codec);
1156                         break;
1157 #if 0 /* XXX: This may cause the silent output on speaker on some machines */
1158                 case 0x10ec0267:
1159                 case 0x10ec0268:
1160                         snd_hda_codec_write(codec, 0x20, 0,
1161                                             AC_VERB_SET_COEF_INDEX, 7);
1162                         tmp = snd_hda_codec_read(codec, 0x20, 0,
1163                                                  AC_VERB_GET_PROC_COEF, 0);
1164                         snd_hda_codec_write(codec, 0x20, 0,
1165                                             AC_VERB_SET_COEF_INDEX, 7);
1166                         snd_hda_codec_write(codec, 0x20, 0,
1167                                             AC_VERB_SET_PROC_COEF,
1168                                             tmp | 0x3000);
1169                         break;
1170 #endif /* XXX */
1171                 }
1172                 break;
1173         }
1174 }
1175
1176 static void alc_init_auto_hp(struct hda_codec *codec)
1177 {
1178         struct alc_spec *spec = codec->spec;
1179
1180         if (!spec->autocfg.hp_pins[0])
1181                 return;
1182
1183         if (!spec->autocfg.speaker_pins[0]) {
1184                 if (spec->autocfg.line_out_pins[0] &&
1185                     spec->autocfg.line_out_type == AUTO_PIN_SPEAKER_OUT)
1186                         spec->autocfg.speaker_pins[0] =
1187                                 spec->autocfg.line_out_pins[0];
1188                 else
1189                         return;
1190         }
1191
1192         snd_printdd("realtek: Enable HP auto-muting on NID 0x%x\n",
1193                     spec->autocfg.hp_pins[0]);
1194         snd_hda_codec_write_cache(codec, spec->autocfg.hp_pins[0], 0,
1195                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1196                                   AC_USRSP_EN | ALC880_HP_EVENT);
1197         spec->unsol_event = alc_sku_unsol_event;
1198 }
1199
1200 static void alc_init_auto_mic(struct hda_codec *codec)
1201 {
1202         struct alc_spec *spec = codec->spec;
1203         struct auto_pin_cfg *cfg = &spec->autocfg;
1204         hda_nid_t fixed, ext;
1205         int i;
1206
1207         /* there must be only two mic inputs exclusively */
1208         for (i = AUTO_PIN_LINE; i < AUTO_PIN_LAST; i++)
1209                 if (cfg->input_pins[i])
1210                         return;
1211
1212         fixed = ext = 0;
1213         for (i = AUTO_PIN_MIC; i <= AUTO_PIN_FRONT_MIC; i++) {
1214                 hda_nid_t nid = cfg->input_pins[i];
1215                 unsigned int defcfg;
1216                 if (!nid)
1217                         return;
1218                 defcfg = snd_hda_codec_get_pincfg(codec, nid);
1219                 switch (get_defcfg_connect(defcfg)) {
1220                 case AC_JACK_PORT_FIXED:
1221                         if (fixed)
1222                                 return; /* already occupied */
1223                         fixed = nid;
1224                         break;
1225                 case AC_JACK_PORT_COMPLEX:
1226                         if (ext)
1227                                 return; /* already occupied */
1228                         ext = nid;
1229                         break;
1230                 default:
1231                         return; /* invalid entry */
1232                 }
1233         }
1234         if (!ext || !fixed)
1235                 return;
1236         if (!(get_wcaps(codec, ext) & AC_WCAP_UNSOL_CAP))
1237                 return; /* no unsol support */
1238         snd_printdd("realtek: Enable auto-mic switch on NID 0x%x/0x%x\n",
1239                     ext, fixed);
1240         spec->ext_mic.pin = ext;
1241         spec->int_mic.pin = fixed;
1242         spec->ext_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1243         spec->int_mic.mux_idx = MUX_IDX_UNDEF; /* set later */
1244         spec->auto_mic = 1;
1245         snd_hda_codec_write_cache(codec, spec->ext_mic.pin, 0,
1246                                   AC_VERB_SET_UNSOLICITED_ENABLE,
1247                                   AC_USRSP_EN | ALC880_MIC_EVENT);
1248         spec->unsol_event = alc_sku_unsol_event;
1249 }
1250
1251 /* check subsystem ID and set up device-specific initialization;
1252  * return 1 if initialized, 0 if invalid SSID
1253  */
1254 /* 32-bit subsystem ID for BIOS loading in HD Audio codec.
1255  *      31 ~ 16 :       Manufacture ID
1256  *      15 ~ 8  :       SKU ID
1257  *      7  ~ 0  :       Assembly ID
1258  *      port-A --> pin 39/41, port-E --> pin 14/15, port-D --> pin 35/36
1259  */
1260 static int alc_subsystem_id(struct hda_codec *codec,
1261                             hda_nid_t porta, hda_nid_t porte,
1262                             hda_nid_t portd, hda_nid_t porti)
1263 {
1264         unsigned int ass, tmp, i;
1265         unsigned nid;
1266         struct alc_spec *spec = codec->spec;
1267
1268         ass = codec->subsystem_id & 0xffff;
1269         if ((ass != codec->bus->pci->subsystem_device) && (ass & 1))
1270                 goto do_sku;
1271
1272         /* invalid SSID, check the special NID pin defcfg instead */
1273         /*
1274          * 31~30        : port connectivity
1275          * 29~21        : reserve
1276          * 20           : PCBEEP input
1277          * 19~16        : Check sum (15:1)
1278          * 15~1         : Custom
1279          * 0            : override
1280         */
1281         nid = 0x1d;
1282         if (codec->vendor_id == 0x10ec0260)
1283                 nid = 0x17;
1284         ass = snd_hda_codec_get_pincfg(codec, nid);
1285         snd_printd("realtek: No valid SSID, "
1286                    "checking pincfg 0x%08x for NID 0x%x\n",
1287                    ass, nid);
1288         if (!(ass & 1))
1289                 return 0;
1290         if ((ass >> 30) != 1)   /* no physical connection */
1291                 return 0;
1292
1293         /* check sum */
1294         tmp = 0;
1295         for (i = 1; i < 16; i++) {
1296                 if ((ass >> i) & 1)
1297                         tmp++;
1298         }
1299         if (((ass >> 16) & 0xf) != tmp)
1300                 return 0;
1301 do_sku:
1302         snd_printd("realtek: Enabling init ASM_ID=0x%04x CODEC_ID=%08x\n",
1303                    ass & 0xffff, codec->vendor_id);
1304         /*
1305          * 0 : override
1306          * 1 :  Swap Jack
1307          * 2 : 0 --> Desktop, 1 --> Laptop
1308          * 3~5 : External Amplifier control
1309          * 7~6 : Reserved
1310         */
1311         tmp = (ass & 0x38) >> 3;        /* external Amp control */
1312         switch (tmp) {
1313         case 1:
1314                 spec->init_amp = ALC_INIT_GPIO1;
1315                 break;
1316         case 3:
1317                 spec->init_amp = ALC_INIT_GPIO2;
1318                 break;
1319         case 7:
1320                 spec->init_amp = ALC_INIT_GPIO3;
1321                 break;
1322         case 5:
1323                 spec->init_amp = ALC_INIT_DEFAULT;
1324                 break;
1325         }
1326
1327         /* is laptop or Desktop and enable the function "Mute internal speaker
1328          * when the external headphone out jack is plugged"
1329          */
1330         if (!(ass & 0x8000))
1331                 return 1;
1332         /*
1333          * 10~8 : Jack location
1334          * 12~11: Headphone out -> 00: PortA, 01: PortE, 02: PortD, 03: Resvered
1335          * 14~13: Resvered
1336          * 15   : 1 --> enable the function "Mute internal speaker
1337          *              when the external headphone out jack is plugged"
1338          */
1339         if (!spec->autocfg.hp_pins[0]) {
1340                 hda_nid_t nid;
1341                 tmp = (ass >> 11) & 0x3;        /* HP to chassis */
1342                 if (tmp == 0)
1343                         nid = porta;
1344                 else if (tmp == 1)
1345                         nid = porte;
1346                 else if (tmp == 2)
1347                         nid = portd;
1348                 else if (tmp == 3)
1349                         nid = porti;
1350                 else
1351                         return 1;
1352                 for (i = 0; i < spec->autocfg.line_outs; i++)
1353                         if (spec->autocfg.line_out_pins[i] == nid)
1354                                 return 1;
1355                 spec->autocfg.hp_pins[0] = nid;
1356         }
1357
1358         alc_init_auto_hp(codec);
1359         alc_init_auto_mic(codec);
1360         return 1;
1361 }
1362
1363 static void alc_ssid_check(struct hda_codec *codec,
1364                            hda_nid_t porta, hda_nid_t porte,
1365                            hda_nid_t portd, hda_nid_t porti)
1366 {
1367         if (!alc_subsystem_id(codec, porta, porte, portd, porti)) {
1368                 struct alc_spec *spec = codec->spec;
1369                 snd_printd("realtek: "
1370                            "Enable default setup for auto mode as fallback\n");
1371                 spec->init_amp = ALC_INIT_DEFAULT;
1372                 alc_init_auto_hp(codec);
1373                 alc_init_auto_mic(codec);
1374         }
1375 }
1376
1377 /*
1378  * Fix-up pin default configurations and add default verbs
1379  */
1380
1381 struct alc_pincfg {
1382         hda_nid_t nid;
1383         u32 val;
1384 };
1385
1386 struct alc_fixup {
1387         const struct alc_pincfg *pins;
1388         const struct hda_verb *verbs;
1389 };
1390
1391 static void alc_pick_fixup(struct hda_codec *codec,
1392                            const struct snd_pci_quirk *quirk,
1393                            const struct alc_fixup *fix)
1394 {
1395         const struct alc_pincfg *cfg;
1396
1397         quirk = snd_pci_quirk_lookup(codec->bus->pci, quirk);
1398         if (!quirk)
1399                 return;
1400
1401         fix += quirk->value;
1402         cfg = fix->pins;
1403         if (cfg) {
1404                 for (; cfg->nid; cfg++)
1405                         snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1406         }
1407         if (fix->verbs)
1408                 add_verb(codec->spec, fix->verbs);
1409 }
1410
1411 static int alc_read_coef_idx(struct hda_codec *codec,
1412                         unsigned int coef_idx)
1413 {
1414         unsigned int val;
1415         snd_hda_codec_write(codec, 0x20, 0, AC_VERB_SET_COEF_INDEX,
1416                                 coef_idx);
1417         val = snd_hda_codec_read(codec, 0x20, 0,
1418                                 AC_VERB_GET_PROC_COEF, 0);
1419         return val;
1420 }
1421
1422 /*
1423  * ALC888
1424  */
1425
1426 /*
1427  * 2ch mode
1428  */
1429 static struct hda_verb alc888_4ST_ch2_intel_init[] = {
1430 /* Mic-in jack as mic in */
1431         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1432         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1433 /* Line-in jack as Line in */
1434         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1435         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1436 /* Line-Out as Front */
1437         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1438         { } /* end */
1439 };
1440
1441 /*
1442  * 4ch mode
1443  */
1444 static struct hda_verb alc888_4ST_ch4_intel_init[] = {
1445 /* Mic-in jack as mic in */
1446         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1447         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1448 /* Line-in jack as Surround */
1449         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1450         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1451 /* Line-Out as Front */
1452         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00},
1453         { } /* end */
1454 };
1455
1456 /*
1457  * 6ch mode
1458  */
1459 static struct hda_verb alc888_4ST_ch6_intel_init[] = {
1460 /* Mic-in jack as CLFE */
1461         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1462         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1463 /* Line-in jack as Surround */
1464         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1465         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1466 /* Line-Out as CLFE (workaround because Mic-in is not loud enough) */
1467         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1468         { } /* end */
1469 };
1470
1471 /*
1472  * 8ch mode
1473  */
1474 static struct hda_verb alc888_4ST_ch8_intel_init[] = {
1475 /* Mic-in jack as CLFE */
1476         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1477         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1478 /* Line-in jack as Surround */
1479         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1480         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1481 /* Line-Out as Side */
1482         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1483         { } /* end */
1484 };
1485
1486 static struct hda_channel_mode alc888_4ST_8ch_intel_modes[4] = {
1487         { 2, alc888_4ST_ch2_intel_init },
1488         { 4, alc888_4ST_ch4_intel_init },
1489         { 6, alc888_4ST_ch6_intel_init },
1490         { 8, alc888_4ST_ch8_intel_init },
1491 };
1492
1493 /*
1494  * ALC888 Fujitsu Siemens Amillo xa3530
1495  */
1496
1497 static struct hda_verb alc888_fujitsu_xa3530_verbs[] = {
1498 /* Front Mic: set to PIN_IN (empty by default) */
1499         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1500 /* Connect Internal HP to Front */
1501         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1502         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1503         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1504 /* Connect Bass HP to Front */
1505         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1506         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1507         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1508 /* Connect Line-Out side jack (SPDIF) to Side */
1509         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1510         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1511         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
1512 /* Connect Mic jack to CLFE */
1513         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1514         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1515         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
1516 /* Connect Line-in jack to Surround */
1517         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1518         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1519         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
1520 /* Connect HP out jack to Front */
1521         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1522         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1523         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
1524 /* Enable unsolicited event for HP jack and Line-out jack */
1525         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1526         {0x17, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1527         {}
1528 };
1529
1530 static void alc_automute_amp(struct hda_codec *codec)
1531 {
1532         struct alc_spec *spec = codec->spec;
1533         unsigned int mute;
1534         hda_nid_t nid;
1535         int i;
1536
1537         spec->jack_present = 0;
1538         for (i = 0; i < ARRAY_SIZE(spec->autocfg.hp_pins); i++) {
1539                 nid = spec->autocfg.hp_pins[i];
1540                 if (!nid)
1541                         break;
1542                 if (snd_hda_jack_detect(codec, nid)) {
1543                         spec->jack_present = 1;
1544                         break;
1545                 }
1546         }
1547
1548         mute = spec->jack_present ? HDA_AMP_MUTE : 0;
1549         /* Toggle internal speakers muting */
1550         for (i = 0; i < ARRAY_SIZE(spec->autocfg.speaker_pins); i++) {
1551                 nid = spec->autocfg.speaker_pins[i];
1552                 if (!nid)
1553                         break;
1554                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
1555                                          HDA_AMP_MUTE, mute);
1556         }
1557 }
1558
1559 static void alc_automute_amp_unsol_event(struct hda_codec *codec,
1560                                          unsigned int res)
1561 {
1562         if (codec->vendor_id == 0x10ec0880)
1563                 res >>= 28;
1564         else
1565                 res >>= 26;
1566         if (res == ALC880_HP_EVENT)
1567                 alc_automute_amp(codec);
1568 }
1569
1570 static void alc889_automute_setup(struct hda_codec *codec)
1571 {
1572         struct alc_spec *spec = codec->spec;
1573
1574         spec->autocfg.hp_pins[0] = 0x15;
1575         spec->autocfg.speaker_pins[0] = 0x14;
1576         spec->autocfg.speaker_pins[1] = 0x16;
1577         spec->autocfg.speaker_pins[2] = 0x17;
1578         spec->autocfg.speaker_pins[3] = 0x19;
1579         spec->autocfg.speaker_pins[4] = 0x1a;
1580 }
1581
1582 static void alc889_intel_init_hook(struct hda_codec *codec)
1583 {
1584         alc889_coef_init(codec);
1585         alc_automute_amp(codec);
1586 }
1587
1588 static void alc888_fujitsu_xa3530_setup(struct hda_codec *codec)
1589 {
1590         struct alc_spec *spec = codec->spec;
1591
1592         spec->autocfg.hp_pins[0] = 0x17; /* line-out */
1593         spec->autocfg.hp_pins[1] = 0x1b; /* hp */
1594         spec->autocfg.speaker_pins[0] = 0x14; /* speaker */
1595         spec->autocfg.speaker_pins[1] = 0x15; /* bass */
1596 }
1597
1598 /*
1599  * ALC888 Acer Aspire 4930G model
1600  */
1601
1602 static struct hda_verb alc888_acer_aspire_4930g_verbs[] = {
1603 /* Front Mic: set to PIN_IN (empty by default) */
1604         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1605 /* Unselect Front Mic by default in input mixer 3 */
1606         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1607 /* Enable unsolicited event for HP jack */
1608         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1609 /* Connect Internal HP to front */
1610         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1611         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1612         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1613 /* Connect HP out to front */
1614         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1615         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1616         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1617         { }
1618 };
1619
1620 /*
1621  * ALC888 Acer Aspire 6530G model
1622  */
1623
1624 static struct hda_verb alc888_acer_aspire_6530g_verbs[] = {
1625 /* Route to built-in subwoofer as well as speakers */
1626         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1627         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1628         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
1629         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
1630 /* Bias voltage on for external mic port */
1631         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN | PIN_VREF80},
1632 /* Front Mic: set to PIN_IN (empty by default) */
1633         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1634 /* Unselect Front Mic by default in input mixer 3 */
1635         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1636 /* Enable unsolicited event for HP jack */
1637         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1638 /* Enable speaker output */
1639         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1640         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1641         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
1642 /* Enable headphone output */
1643         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1644         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1645         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1646         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
1647         { }
1648 };
1649
1650 /*
1651  * ALC889 Acer Aspire 8930G model
1652  */
1653
1654 static struct hda_verb alc889_acer_aspire_8930g_verbs[] = {
1655 /* Front Mic: set to PIN_IN (empty by default) */
1656         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
1657 /* Unselect Front Mic by default in input mixer 3 */
1658         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0xb)},
1659 /* Enable unsolicited event for HP jack */
1660         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
1661 /* Connect Internal Front to Front */
1662         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1663         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1664         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
1665 /* Connect Internal Rear to Rear */
1666         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1667         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1668         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
1669 /* Connect Internal CLFE to CLFE */
1670         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
1671         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1672         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
1673 /* Connect HP out to Front */
1674         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | PIN_HP},
1675         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
1676         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
1677 /* Enable all DACs */
1678 /*  DAC DISABLE/MUTE 1? */
1679 /*  setting bits 1-5 disables DAC nids 0x02-0x06 apparently. Init=0x38 */
1680         {0x20, AC_VERB_SET_COEF_INDEX, 0x03},
1681         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1682 /*  DAC DISABLE/MUTE 2? */
1683 /*  some bit here disables the other DACs. Init=0x4900 */
1684         {0x20, AC_VERB_SET_COEF_INDEX, 0x08},
1685         {0x20, AC_VERB_SET_PROC_COEF, 0x0000},
1686 /* DMIC fix
1687  * This laptop has a stereo digital microphone. The mics are only 1cm apart
1688  * which makes the stereo useless. However, either the mic or the ALC889
1689  * makes the signal become a difference/sum signal instead of standard
1690  * stereo, which is annoying. So instead we flip this bit which makes the
1691  * codec replicate the sum signal to both channels, turning it into a
1692  * normal mono mic.
1693  */
1694 /*  DMIC_CONTROL? Init value = 0x0001 */
1695         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
1696         {0x20, AC_VERB_SET_PROC_COEF, 0x0003},
1697         { }
1698 };
1699
1700 static struct hda_input_mux alc888_2_capture_sources[2] = {
1701         /* Front mic only available on one ADC */
1702         {
1703                 .num_items = 4,
1704                 .items = {
1705                         { "Mic", 0x0 },
1706                         { "Line", 0x2 },
1707                         { "CD", 0x4 },
1708                         { "Front Mic", 0xb },
1709                 },
1710         },
1711         {
1712                 .num_items = 3,
1713                 .items = {
1714                         { "Mic", 0x0 },
1715                         { "Line", 0x2 },
1716                         { "CD", 0x4 },
1717                 },
1718         }
1719 };
1720
1721 static struct hda_input_mux alc888_acer_aspire_6530_sources[2] = {
1722         /* Interal mic only available on one ADC */
1723         {
1724                 .num_items = 5,
1725                 .items = {
1726                         { "Ext Mic", 0x0 },
1727                         { "Line In", 0x2 },
1728                         { "CD", 0x4 },
1729                         { "Input Mix", 0xa },
1730                         { "Int Mic", 0xb },
1731                 },
1732         },
1733         {
1734                 .num_items = 4,
1735                 .items = {
1736                         { "Ext Mic", 0x0 },
1737                         { "Line In", 0x2 },
1738                         { "CD", 0x4 },
1739                         { "Input Mix", 0xa },
1740                 },
1741         }
1742 };
1743
1744 static struct hda_input_mux alc889_capture_sources[3] = {
1745         /* Digital mic only available on first "ADC" */
1746         {
1747                 .num_items = 5,
1748                 .items = {
1749                         { "Mic", 0x0 },
1750                         { "Line", 0x2 },
1751                         { "CD", 0x4 },
1752                         { "Front Mic", 0xb },
1753                         { "Input Mix", 0xa },
1754                 },
1755         },
1756         {
1757                 .num_items = 4,
1758                 .items = {
1759                         { "Mic", 0x0 },
1760                         { "Line", 0x2 },
1761                         { "CD", 0x4 },
1762                         { "Input Mix", 0xa },
1763                 },
1764         },
1765         {
1766                 .num_items = 4,
1767                 .items = {
1768                         { "Mic", 0x0 },
1769                         { "Line", 0x2 },
1770                         { "CD", 0x4 },
1771                         { "Input Mix", 0xa },
1772                 },
1773         }
1774 };
1775
1776 static struct snd_kcontrol_new alc888_base_mixer[] = {
1777         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1778         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1779         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1780         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1781         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1782                 HDA_OUTPUT),
1783         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1784         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1785         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1786         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1787         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
1788         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1789         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1790         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1791         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1792         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1793         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1794         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1795         { } /* end */
1796 };
1797
1798 static struct snd_kcontrol_new alc889_acer_aspire_8930g_mixer[] = {
1799         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1800         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1801         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
1802         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
1803         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
1804                 HDA_OUTPUT),
1805         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1806         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1807         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1808         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1809         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1810         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1811         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
1812         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1813         { } /* end */
1814 };
1815
1816
1817 static void alc888_acer_aspire_4930g_setup(struct hda_codec *codec)
1818 {
1819         struct alc_spec *spec = codec->spec;
1820
1821         spec->autocfg.hp_pins[0] = 0x15;
1822         spec->autocfg.speaker_pins[0] = 0x14;
1823         spec->autocfg.speaker_pins[1] = 0x16;
1824         spec->autocfg.speaker_pins[2] = 0x17;
1825 }
1826
1827 static void alc888_acer_aspire_6530g_setup(struct hda_codec *codec)
1828 {
1829         struct alc_spec *spec = codec->spec;
1830
1831         spec->autocfg.hp_pins[0] = 0x15;
1832         spec->autocfg.speaker_pins[0] = 0x14;
1833         spec->autocfg.speaker_pins[1] = 0x16;
1834         spec->autocfg.speaker_pins[2] = 0x17;
1835 }
1836
1837 static void alc889_acer_aspire_8930g_setup(struct hda_codec *codec)
1838 {
1839         struct alc_spec *spec = codec->spec;
1840
1841         spec->autocfg.hp_pins[0] = 0x15;
1842         spec->autocfg.speaker_pins[0] = 0x14;
1843         spec->autocfg.speaker_pins[1] = 0x16;
1844         spec->autocfg.speaker_pins[2] = 0x1b;
1845 }
1846
1847 /*
1848  * ALC880 3-stack model
1849  *
1850  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0e)
1851  * Pin assignment: Front = 0x14, Line-In/Surr = 0x1a, Mic/CLFE = 0x18,
1852  *                 F-Mic = 0x1b, HP = 0x19
1853  */
1854
1855 static hda_nid_t alc880_dac_nids[4] = {
1856         /* front, rear, clfe, rear_surr */
1857         0x02, 0x05, 0x04, 0x03
1858 };
1859
1860 static hda_nid_t alc880_adc_nids[3] = {
1861         /* ADC0-2 */
1862         0x07, 0x08, 0x09,
1863 };
1864
1865 /* The datasheet says the node 0x07 is connected from inputs,
1866  * but it shows zero connection in the real implementation on some devices.
1867  * Note: this is a 915GAV bug, fixed on 915GLV
1868  */
1869 static hda_nid_t alc880_adc_nids_alt[2] = {
1870         /* ADC1-2 */
1871         0x08, 0x09,
1872 };
1873
1874 #define ALC880_DIGOUT_NID       0x06
1875 #define ALC880_DIGIN_NID        0x0a
1876
1877 static struct hda_input_mux alc880_capture_source = {
1878         .num_items = 4,
1879         .items = {
1880                 { "Mic", 0x0 },
1881                 { "Front Mic", 0x3 },
1882                 { "Line", 0x2 },
1883                 { "CD", 0x4 },
1884         },
1885 };
1886
1887 /* channel source setting (2/6 channel selection for 3-stack) */
1888 /* 2ch mode */
1889 static struct hda_verb alc880_threestack_ch2_init[] = {
1890         /* set line-in to input, mute it */
1891         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
1892         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1893         /* set mic-in to input vref 80%, mute it */
1894         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
1895         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
1896         { } /* end */
1897 };
1898
1899 /* 6ch mode */
1900 static struct hda_verb alc880_threestack_ch6_init[] = {
1901         /* set line-in to output, unmute it */
1902         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1903         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1904         /* set mic-in to output, unmute it */
1905         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
1906         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
1907         { } /* end */
1908 };
1909
1910 static struct hda_channel_mode alc880_threestack_modes[2] = {
1911         { 2, alc880_threestack_ch2_init },
1912         { 6, alc880_threestack_ch6_init },
1913 };
1914
1915 static struct snd_kcontrol_new alc880_three_stack_mixer[] = {
1916         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
1917         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
1918         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
1919         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
1920         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
1921         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
1922         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
1923         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
1924         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
1925         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
1926         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
1927         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
1928         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
1929         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
1930         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
1931         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
1932         HDA_CODEC_MUTE("Headphone Playback Switch", 0x19, 0x0, HDA_OUTPUT),
1933         {
1934                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
1935                 .name = "Channel Mode",
1936                 .info = alc_ch_mode_info,
1937                 .get = alc_ch_mode_get,
1938                 .put = alc_ch_mode_put,
1939         },
1940         { } /* end */
1941 };
1942
1943 /* capture mixer elements */
1944 static int alc_cap_vol_info(struct snd_kcontrol *kcontrol,
1945                             struct snd_ctl_elem_info *uinfo)
1946 {
1947         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1948         struct alc_spec *spec = codec->spec;
1949         int err;
1950
1951         mutex_lock(&codec->control_mutex);
1952         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1953                                                       HDA_INPUT);
1954         err = snd_hda_mixer_amp_volume_info(kcontrol, uinfo);
1955         mutex_unlock(&codec->control_mutex);
1956         return err;
1957 }
1958
1959 static int alc_cap_vol_tlv(struct snd_kcontrol *kcontrol, int op_flag,
1960                            unsigned int size, unsigned int __user *tlv)
1961 {
1962         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1963         struct alc_spec *spec = codec->spec;
1964         int err;
1965
1966         mutex_lock(&codec->control_mutex);
1967         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[0], 3, 0,
1968                                                       HDA_INPUT);
1969         err = snd_hda_mixer_amp_tlv(kcontrol, op_flag, size, tlv);
1970         mutex_unlock(&codec->control_mutex);
1971         return err;
1972 }
1973
1974 typedef int (*getput_call_t)(struct snd_kcontrol *kcontrol,
1975                              struct snd_ctl_elem_value *ucontrol);
1976
1977 static int alc_cap_getput_caller(struct snd_kcontrol *kcontrol,
1978                                  struct snd_ctl_elem_value *ucontrol,
1979                                  getput_call_t func)
1980 {
1981         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
1982         struct alc_spec *spec = codec->spec;
1983         unsigned int adc_idx = snd_ctl_get_ioffidx(kcontrol, &ucontrol->id);
1984         int err;
1985
1986         mutex_lock(&codec->control_mutex);
1987         kcontrol->private_value = HDA_COMPOSE_AMP_VAL(spec->adc_nids[adc_idx],
1988                                                       3, 0, HDA_INPUT);
1989         err = func(kcontrol, ucontrol);
1990         mutex_unlock(&codec->control_mutex);
1991         return err;
1992 }
1993
1994 static int alc_cap_vol_get(struct snd_kcontrol *kcontrol,
1995                            struct snd_ctl_elem_value *ucontrol)
1996 {
1997         return alc_cap_getput_caller(kcontrol, ucontrol,
1998                                      snd_hda_mixer_amp_volume_get);
1999 }
2000
2001 static int alc_cap_vol_put(struct snd_kcontrol *kcontrol,
2002                            struct snd_ctl_elem_value *ucontrol)
2003 {
2004         return alc_cap_getput_caller(kcontrol, ucontrol,
2005                                      snd_hda_mixer_amp_volume_put);
2006 }
2007
2008 /* capture mixer elements */
2009 #define alc_cap_sw_info         snd_ctl_boolean_stereo_info
2010
2011 static int alc_cap_sw_get(struct snd_kcontrol *kcontrol,
2012                           struct snd_ctl_elem_value *ucontrol)
2013 {
2014         return alc_cap_getput_caller(kcontrol, ucontrol,
2015                                      snd_hda_mixer_amp_switch_get);
2016 }
2017
2018 static int alc_cap_sw_put(struct snd_kcontrol *kcontrol,
2019                           struct snd_ctl_elem_value *ucontrol)
2020 {
2021         return alc_cap_getput_caller(kcontrol, ucontrol,
2022                                      snd_hda_mixer_amp_switch_put);
2023 }
2024
2025 #define _DEFINE_CAPMIX(num) \
2026         { \
2027                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2028                 .name = "Capture Switch", \
2029                 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
2030                 .count = num, \
2031                 .info = alc_cap_sw_info, \
2032                 .get = alc_cap_sw_get, \
2033                 .put = alc_cap_sw_put, \
2034         }, \
2035         { \
2036                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2037                 .name = "Capture Volume", \
2038                 .access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | \
2039                            SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
2040                            SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK), \
2041                 .count = num, \
2042                 .info = alc_cap_vol_info, \
2043                 .get = alc_cap_vol_get, \
2044                 .put = alc_cap_vol_put, \
2045                 .tlv = { .c = alc_cap_vol_tlv }, \
2046         }
2047
2048 #define _DEFINE_CAPSRC(num) \
2049         { \
2050                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
2051                 /* .name = "Capture Source", */ \
2052                 .name = "Input Source", \
2053                 .count = num, \
2054                 .info = alc_mux_enum_info, \
2055                 .get = alc_mux_enum_get, \
2056                 .put = alc_mux_enum_put, \
2057         }
2058
2059 #define DEFINE_CAPMIX(num) \
2060 static struct snd_kcontrol_new alc_capture_mixer ## num[] = { \
2061         _DEFINE_CAPMIX(num),                                  \
2062         _DEFINE_CAPSRC(num),                                  \
2063         { } /* end */                                         \
2064 }
2065
2066 #define DEFINE_CAPMIX_NOSRC(num) \
2067 static struct snd_kcontrol_new alc_capture_mixer_nosrc ## num[] = { \
2068         _DEFINE_CAPMIX(num),                                        \
2069         { } /* end */                                               \
2070 }
2071
2072 /* up to three ADCs */
2073 DEFINE_CAPMIX(1);
2074 DEFINE_CAPMIX(2);
2075 DEFINE_CAPMIX(3);
2076 DEFINE_CAPMIX_NOSRC(1);
2077 DEFINE_CAPMIX_NOSRC(2);
2078 DEFINE_CAPMIX_NOSRC(3);
2079
2080 /*
2081  * ALC880 5-stack model
2082  *
2083  * DAC: Front = 0x02 (0x0c), Surr = 0x05 (0x0f), CLFE = 0x04 (0x0d),
2084  *      Side = 0x02 (0xd)
2085  * Pin assignment: Front = 0x14, Surr = 0x17, CLFE = 0x16
2086  *                 Line-In/Side = 0x1a, Mic = 0x18, F-Mic = 0x1b, HP = 0x19
2087  */
2088
2089 /* additional mixers to alc880_three_stack_mixer */
2090 static struct snd_kcontrol_new alc880_five_stack_mixer[] = {
2091         HDA_CODEC_VOLUME("Side Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2092         HDA_BIND_MUTE("Side Playback Switch", 0x0d, 2, HDA_INPUT),
2093         { } /* end */
2094 };
2095
2096 /* channel source setting (6/8 channel selection for 5-stack) */
2097 /* 6ch mode */
2098 static struct hda_verb alc880_fivestack_ch6_init[] = {
2099         /* set line-in to input, mute it */
2100         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
2101         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
2102         { } /* end */
2103 };
2104
2105 /* 8ch mode */
2106 static struct hda_verb alc880_fivestack_ch8_init[] = {
2107         /* set line-in to output, unmute it */
2108         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
2109         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
2110         { } /* end */
2111 };
2112
2113 static struct hda_channel_mode alc880_fivestack_modes[2] = {
2114         { 6, alc880_fivestack_ch6_init },
2115         { 8, alc880_fivestack_ch8_init },
2116 };
2117
2118
2119 /*
2120  * ALC880 6-stack model
2121  *
2122  * DAC: Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e),
2123  *      Side = 0x05 (0x0f)
2124  * Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, Side = 0x17,
2125  *   Mic = 0x18, F-Mic = 0x19, Line = 0x1a, HP = 0x1b
2126  */
2127
2128 static hda_nid_t alc880_6st_dac_nids[4] = {
2129         /* front, rear, clfe, rear_surr */
2130         0x02, 0x03, 0x04, 0x05
2131 };
2132
2133 static struct hda_input_mux alc880_6stack_capture_source = {
2134         .num_items = 4,
2135         .items = {
2136                 { "Mic", 0x0 },
2137                 { "Front Mic", 0x1 },
2138                 { "Line", 0x2 },
2139                 { "CD", 0x4 },
2140         },
2141 };
2142
2143 /* fixed 8-channels */
2144 static struct hda_channel_mode alc880_sixstack_modes[1] = {
2145         { 8, NULL },
2146 };
2147
2148 static struct snd_kcontrol_new alc880_six_stack_mixer[] = {
2149         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2150         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2151         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2152         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2153         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2154         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2155         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2156         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2157         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
2158         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
2159         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2160         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2161         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2162         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2163         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2164         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2165         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2166         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2167         {
2168                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2169                 .name = "Channel Mode",
2170                 .info = alc_ch_mode_info,
2171                 .get = alc_ch_mode_get,
2172                 .put = alc_ch_mode_put,
2173         },
2174         { } /* end */
2175 };
2176
2177
2178 /*
2179  * ALC880 W810 model
2180  *
2181  * W810 has rear IO for:
2182  * Front (DAC 02)
2183  * Surround (DAC 03)
2184  * Center/LFE (DAC 04)
2185  * Digital out (06)
2186  *
2187  * The system also has a pair of internal speakers, and a headphone jack.
2188  * These are both connected to Line2 on the codec, hence to DAC 02.
2189  *
2190  * There is a variable resistor to control the speaker or headphone
2191  * volume. This is a hardware-only device without a software API.
2192  *
2193  * Plugging headphones in will disable the internal speakers. This is
2194  * implemented in hardware, not via the driver using jack sense. In
2195  * a similar fashion, plugging into the rear socket marked "front" will
2196  * disable both the speakers and headphones.
2197  *
2198  * For input, there's a microphone jack, and an "audio in" jack.
2199  * These may not do anything useful with this driver yet, because I
2200  * haven't setup any initialization verbs for these yet...
2201  */
2202
2203 static hda_nid_t alc880_w810_dac_nids[3] = {
2204         /* front, rear/surround, clfe */
2205         0x02, 0x03, 0x04
2206 };
2207
2208 /* fixed 6 channels */
2209 static struct hda_channel_mode alc880_w810_modes[1] = {
2210         { 6, NULL }
2211 };
2212
2213 /* Pin assignment: Front = 0x14, Surr = 0x15, CLFE = 0x16, HP = 0x1b */
2214 static struct snd_kcontrol_new alc880_w810_base_mixer[] = {
2215         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2216         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2217         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2218         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2219         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2220         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2221         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2222         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2223         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2224         { } /* end */
2225 };
2226
2227
2228 /*
2229  * Z710V model
2230  *
2231  * DAC: Front = 0x02 (0x0c), HP = 0x03 (0x0d)
2232  * Pin assignment: Front = 0x14, HP = 0x15, Mic = 0x18, Mic2 = 0x19(?),
2233  *                 Line = 0x1a
2234  */
2235
2236 static hda_nid_t alc880_z71v_dac_nids[1] = {
2237         0x02
2238 };
2239 #define ALC880_Z71V_HP_DAC      0x03
2240
2241 /* fixed 2 channels */
2242 static struct hda_channel_mode alc880_2_jack_modes[1] = {
2243         { 2, NULL }
2244 };
2245
2246 static struct snd_kcontrol_new alc880_z71v_mixer[] = {
2247         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2248         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2249         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2250         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
2251         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2252         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2253         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2254         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2255         { } /* end */
2256 };
2257
2258
2259 /*
2260  * ALC880 F1734 model
2261  *
2262  * DAC: HP = 0x02 (0x0c), Front = 0x03 (0x0d)
2263  * Pin assignment: HP = 0x14, Front = 0x15, Mic = 0x18
2264  */
2265
2266 static hda_nid_t alc880_f1734_dac_nids[1] = {
2267         0x03
2268 };
2269 #define ALC880_F1734_HP_DAC     0x02
2270
2271 static struct snd_kcontrol_new alc880_f1734_mixer[] = {
2272         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2273         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2274         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2275         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2276         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2277         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2278         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2279         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2280         { } /* end */
2281 };
2282
2283 static struct hda_input_mux alc880_f1734_capture_source = {
2284         .num_items = 2,
2285         .items = {
2286                 { "Mic", 0x1 },
2287                 { "CD", 0x4 },
2288         },
2289 };
2290
2291
2292 /*
2293  * ALC880 ASUS model
2294  *
2295  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2296  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2297  *  Mic = 0x18, Line = 0x1a
2298  */
2299
2300 #define alc880_asus_dac_nids    alc880_w810_dac_nids    /* identical with w810 */
2301 #define alc880_asus_modes       alc880_threestack_modes /* 2/6 channel mode */
2302
2303 static struct snd_kcontrol_new alc880_asus_mixer[] = {
2304         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2305         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
2306         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2307         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
2308         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2309         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2310         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2311         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2312         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2313         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2314         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2315         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2316         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2317         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2318         {
2319                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2320                 .name = "Channel Mode",
2321                 .info = alc_ch_mode_info,
2322                 .get = alc_ch_mode_get,
2323                 .put = alc_ch_mode_put,
2324         },
2325         { } /* end */
2326 };
2327
2328 /*
2329  * ALC880 ASUS W1V model
2330  *
2331  * DAC: HP/Front = 0x02 (0x0c), Surr = 0x03 (0x0d), CLFE = 0x04 (0x0e)
2332  * Pin assignment: HP/Front = 0x14, Surr = 0x15, CLFE = 0x16,
2333  *  Mic = 0x18, Line = 0x1a, Line2 = 0x1b
2334  */
2335
2336 /* additional mixers to alc880_asus_mixer */
2337 static struct snd_kcontrol_new alc880_asus_w1v_mixer[] = {
2338         HDA_CODEC_VOLUME("Line2 Playback Volume", 0x0b, 0x03, HDA_INPUT),
2339         HDA_CODEC_MUTE("Line2 Playback Switch", 0x0b, 0x03, HDA_INPUT),
2340         { } /* end */
2341 };
2342
2343 /* TCL S700 */
2344 static struct snd_kcontrol_new alc880_tcl_s700_mixer[] = {
2345         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2346         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
2347         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
2348         HDA_CODEC_VOLUME("CD Playback Volume", 0x0B, 0x04, HDA_INPUT),
2349         HDA_CODEC_MUTE("CD Playback Switch", 0x0B, 0x04, HDA_INPUT),
2350         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0B, 0x0, HDA_INPUT),
2351         HDA_CODEC_MUTE("Mic Playback Switch", 0x0B, 0x0, HDA_INPUT),
2352         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
2353         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
2354         { } /* end */
2355 };
2356
2357 /* Uniwill */
2358 static struct snd_kcontrol_new alc880_uniwill_mixer[] = {
2359         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2360         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2361         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2362         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2363         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
2364         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
2365         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
2366         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
2367         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2368         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2369         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
2370         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
2371         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2372         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2373         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2374         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2375         {
2376                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
2377                 .name = "Channel Mode",
2378                 .info = alc_ch_mode_info,
2379                 .get = alc_ch_mode_get,
2380                 .put = alc_ch_mode_put,
2381         },
2382         { } /* end */
2383 };
2384
2385 static struct snd_kcontrol_new alc880_fujitsu_mixer[] = {
2386         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2387         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2388         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2389         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2390         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
2391         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
2392         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2393         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2394         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
2395         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
2396         { } /* end */
2397 };
2398
2399 static struct snd_kcontrol_new alc880_uniwill_p53_mixer[] = {
2400         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
2401         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
2402         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
2403         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
2404         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
2405         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
2406         { } /* end */
2407 };
2408
2409 /*
2410  * virtual master controls
2411  */
2412
2413 /*
2414  * slave controls for virtual master
2415  */
2416 static const char *alc_slave_vols[] = {
2417         "Front Playback Volume",
2418         "Surround Playback Volume",
2419         "Center Playback Volume",
2420         "LFE Playback Volume",
2421         "Side Playback Volume",
2422         "Headphone Playback Volume",
2423         "Speaker Playback Volume",
2424         "Mono Playback Volume",
2425         "Line-Out Playback Volume",
2426         "PCM Playback Volume",
2427         NULL,
2428 };
2429
2430 static const char *alc_slave_sws[] = {
2431         "Front Playback Switch",
2432         "Surround Playback Switch",
2433         "Center Playback Switch",
2434         "LFE Playback Switch",
2435         "Side Playback Switch",
2436         "Headphone Playback Switch",
2437         "Speaker Playback Switch",
2438         "Mono Playback Switch",
2439         "IEC958 Playback Switch",
2440         "Line-Out Playback Switch",
2441         "PCM Playback Switch",
2442         NULL,
2443 };
2444
2445 /*
2446  * build control elements
2447  */
2448
2449 #define NID_MAPPING             (-1)
2450
2451 #define SUBDEV_SPEAKER_         (0 << 6)
2452 #define SUBDEV_HP_              (1 << 6)
2453 #define SUBDEV_LINE_            (2 << 6)
2454 #define SUBDEV_SPEAKER(x)       (SUBDEV_SPEAKER_ | ((x) & 0x3f))
2455 #define SUBDEV_HP(x)            (SUBDEV_HP_ | ((x) & 0x3f))
2456 #define SUBDEV_LINE(x)          (SUBDEV_LINE_ | ((x) & 0x3f))
2457
2458 static void alc_free_kctls(struct hda_codec *codec);
2459
2460 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2461 /* additional beep mixers; the actual parameters are overwritten at build */
2462 static struct snd_kcontrol_new alc_beep_mixer[] = {
2463         HDA_CODEC_VOLUME("Beep Playback Volume", 0, 0, HDA_INPUT),
2464         HDA_CODEC_MUTE_BEEP("Beep Playback Switch", 0, 0, HDA_INPUT),
2465         { } /* end */
2466 };
2467 #endif
2468
2469 static int alc_build_controls(struct hda_codec *codec)
2470 {
2471         struct alc_spec *spec = codec->spec;
2472         struct snd_kcontrol *kctl;
2473         struct snd_kcontrol_new *knew;
2474         int i, j, err;
2475         unsigned int u;
2476         hda_nid_t nid;
2477
2478         for (i = 0; i < spec->num_mixers; i++) {
2479                 err = snd_hda_add_new_ctls(codec, spec->mixers[i]);
2480                 if (err < 0)
2481                         return err;
2482         }
2483         if (spec->cap_mixer) {
2484                 err = snd_hda_add_new_ctls(codec, spec->cap_mixer);
2485                 if (err < 0)
2486                         return err;
2487         }
2488         if (spec->multiout.dig_out_nid) {
2489                 err = snd_hda_create_spdif_out_ctls(codec,
2490                                                     spec->multiout.dig_out_nid);
2491                 if (err < 0)
2492                         return err;
2493                 if (!spec->no_analog) {
2494                         err = snd_hda_create_spdif_share_sw(codec,
2495                                                             &spec->multiout);
2496                         if (err < 0)
2497                                 return err;
2498                         spec->multiout.share_spdif = 1;
2499                 }
2500         }
2501         if (spec->dig_in_nid) {
2502                 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in_nid);
2503                 if (err < 0)
2504                         return err;
2505         }
2506
2507 #ifdef CONFIG_SND_HDA_INPUT_BEEP
2508         /* create beep controls if needed */
2509         if (spec->beep_amp) {
2510                 struct snd_kcontrol_new *knew;
2511                 for (knew = alc_beep_mixer; knew->name; knew++) {
2512                         struct snd_kcontrol *kctl;
2513                         kctl = snd_ctl_new1(knew, codec);
2514                         if (!kctl)
2515                                 return -ENOMEM;
2516                         kctl->private_value = spec->beep_amp;
2517                         err = snd_hda_ctl_add(codec, 0, kctl);
2518                         if (err < 0)
2519                                 return err;
2520                 }
2521         }
2522 #endif
2523
2524         /* if we have no master control, let's create it */
2525         if (!spec->no_analog &&
2526             !snd_hda_find_mixer_ctl(codec, "Master Playback Volume")) {
2527                 unsigned int vmaster_tlv[4];
2528                 snd_hda_set_vmaster_tlv(codec, spec->vmaster_nid,
2529                                         HDA_OUTPUT, vmaster_tlv);
2530                 err = snd_hda_add_vmaster(codec, "Master Playback Volume",
2531                                           vmaster_tlv, alc_slave_vols);
2532                 if (err < 0)
2533                         return err;
2534         }
2535         if (!spec->no_analog &&
2536             !snd_hda_find_mixer_ctl(codec, "Master Playback Switch")) {
2537                 err = snd_hda_add_vmaster(codec, "Master Playback Switch",
2538                                           NULL, alc_slave_sws);
2539                 if (err < 0)
2540                         return err;
2541         }
2542
2543         /* assign Capture Source enums to NID */
2544         kctl = snd_hda_find_mixer_ctl(codec, "Capture Source");
2545         if (!kctl)
2546                 kctl = snd_hda_find_mixer_ctl(codec, "Input Source");
2547         for (i = 0; kctl && i < kctl->count; i++) {
2548                 hda_nid_t *nids = spec->capsrc_nids;
2549                 if (!nids)
2550                         nids = spec->adc_nids;
2551                 err = snd_hda_add_nid(codec, kctl, i, nids[i]);
2552                 if (err < 0)
2553                         return err;
2554         }
2555         if (spec->cap_mixer) {
2556                 const char *kname = kctl ? kctl->id.name : NULL;
2557                 for (knew = spec->cap_mixer; knew->name; knew++) {
2558                         if (kname && strcmp(knew->name, kname) == 0)
2559                                 continue;
2560                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2561                         for (i = 0; kctl && i < kctl->count; i++) {
2562                                 err = snd_hda_add_nid(codec, kctl, i,
2563                                                       spec->adc_nids[i]);
2564                                 if (err < 0)
2565                                         return err;
2566                         }
2567                 }
2568         }
2569
2570         /* other nid->control mapping */
2571         for (i = 0; i < spec->num_mixers; i++) {
2572                 for (knew = spec->mixers[i]; knew->name; knew++) {
2573                         if (knew->iface != NID_MAPPING)
2574                                 continue;
2575                         kctl = snd_hda_find_mixer_ctl(codec, knew->name);
2576                         if (kctl == NULL)
2577                                 continue;
2578                         u = knew->subdevice;
2579                         for (j = 0; j < 4; j++, u >>= 8) {
2580                                 nid = u & 0x3f;
2581                                 if (nid == 0)
2582                                         continue;
2583                                 switch (u & 0xc0) {
2584                                 case SUBDEV_SPEAKER_:
2585                                         nid = spec->autocfg.speaker_pins[nid];
2586                                         break;
2587                                 case SUBDEV_LINE_:
2588                                         nid = spec->autocfg.line_out_pins[nid];
2589                                         break;
2590                                 case SUBDEV_HP_:
2591                                         nid = spec->autocfg.hp_pins[nid];
2592                                         break;
2593                                 default:
2594                                         continue;
2595                                 }
2596                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2597                                 if (err < 0)
2598                                         return err;
2599                         }
2600                         u = knew->private_value;
2601                         for (j = 0; j < 4; j++, u >>= 8) {
2602                                 nid = u & 0xff;
2603                                 if (nid == 0)
2604                                         continue;
2605                                 err = snd_hda_add_nid(codec, kctl, 0, nid);
2606                                 if (err < 0)
2607                                         return err;
2608                         }
2609                 }
2610         }
2611
2612         alc_free_kctls(codec); /* no longer needed */
2613
2614         return 0;
2615 }
2616
2617
2618 /*
2619  * initialize the codec volumes, etc
2620  */
2621
2622 /*
2623  * generic initialization of ADC, input mixers and output mixers
2624  */
2625 static struct hda_verb alc880_volume_init_verbs[] = {
2626         /*
2627          * Unmute ADC0-2 and set the default input to mic-in
2628          */
2629         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
2630         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2631         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
2632         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2633         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
2634         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
2635
2636         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
2637          * mixer widget
2638          * Note: PASD motherboards uses the Line In 2 as the input for front
2639          * panel mic (mic 2)
2640          */
2641         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
2642         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2643         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2644         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
2645         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
2646         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
2647         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
2648         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
2649
2650         /*
2651          * Set up output mixers (0x0c - 0x0f)
2652          */
2653         /* set vol=0 to output mixers */
2654         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2655         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2656         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2657         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
2658         /* set up input amps for analog loopback */
2659         /* Amp Indices: DAC = 0, mixer = 1 */
2660         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2661         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2662         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2663         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2664         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2665         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2666         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
2667         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
2668
2669         { }
2670 };
2671
2672 /*
2673  * 3-stack pin configuration:
2674  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
2675  */
2676 static struct hda_verb alc880_pin_3stack_init_verbs[] = {
2677         /*
2678          * preset connection lists of input pins
2679          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2680          */
2681         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
2682         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2683         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
2684
2685         /*
2686          * Set pin mode and muting
2687          */
2688         /* set front pin widgets 0x14 for output */
2689         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2690         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2691         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2692         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2693         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2694         /* Mic2 (as headphone out) for HP output */
2695         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2696         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2697         /* Line In pin widget for input */
2698         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2699         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2700         /* Line2 (as front mic) pin widget for input and vref at 80% */
2701         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2702         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2703         /* CD pin widget for input */
2704         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2705
2706         { }
2707 };
2708
2709 /*
2710  * 5-stack pin configuration:
2711  * front = 0x14, surround = 0x17, clfe = 0x16, mic = 0x18, HP = 0x19,
2712  * line-in/side = 0x1a, f-mic = 0x1b
2713  */
2714 static struct hda_verb alc880_pin_5stack_init_verbs[] = {
2715         /*
2716          * preset connection lists of input pins
2717          * 0 = front, 1 = rear_surr, 2 = CLFE, 3 = surround
2718          */
2719         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2720         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/side */
2721
2722         /*
2723          * Set pin mode and muting
2724          */
2725         /* set pin widgets 0x14-0x17 for output */
2726         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2727         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2728         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2729         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2730         /* unmute pins for output (no gain on this amp) */
2731         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2732         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2733         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2734         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2735
2736         /* Mic1 (rear panel) pin widget for input and vref at 80% */
2737         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2738         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2739         /* Mic2 (as headphone out) for HP output */
2740         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2741         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2742         /* Line In pin widget for input */
2743         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2744         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2745         /* Line2 (as front mic) pin widget for input and vref at 80% */
2746         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2747         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2748         /* CD pin widget for input */
2749         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2750
2751         { }
2752 };
2753
2754 /*
2755  * W810 pin configuration:
2756  * front = 0x14, surround = 0x15, clfe = 0x16, HP = 0x1b
2757  */
2758 static struct hda_verb alc880_pin_w810_init_verbs[] = {
2759         /* hphone/speaker input selector: front DAC */
2760         {0x13, AC_VERB_SET_CONNECT_SEL, 0x0},
2761
2762         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2763         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2764         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2765         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2766         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2767         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2768
2769         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2770         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2771
2772         { }
2773 };
2774
2775 /*
2776  * Z71V pin configuration:
2777  * Speaker-out = 0x14, HP = 0x15, Mic = 0x18, Line-in = 0x1a, Mic2 = 0x1b (?)
2778  */
2779 static struct hda_verb alc880_pin_z71v_init_verbs[] = {
2780         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2781         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2782         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2783         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2784
2785         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2786         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2787         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2788         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2789
2790         { }
2791 };
2792
2793 /*
2794  * 6-stack pin configuration:
2795  * front = 0x14, surr = 0x15, clfe = 0x16, side = 0x17, mic = 0x18,
2796  * f-mic = 0x19, line = 0x1a, HP = 0x1b
2797  */
2798 static struct hda_verb alc880_pin_6stack_init_verbs[] = {
2799         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2800
2801         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2802         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2804         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2805         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2806         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2807         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2808         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2809
2810         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2811         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2812         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2813         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2814         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2815         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2816         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2817         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2818         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2819
2820         { }
2821 };
2822
2823 /*
2824  * Uniwill pin configuration:
2825  * HP = 0x14, InternalSpeaker = 0x15, mic = 0x18, internal mic = 0x19,
2826  * line = 0x1a
2827  */
2828 static struct hda_verb alc880_uniwill_init_verbs[] = {
2829         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2830
2831         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2832         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2833         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2834         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2835         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2836         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2837         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2838         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2839         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2840         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2841         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2842         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2843         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2844         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2845
2846         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2847         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2848         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2849         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2850         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2851         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2852         /* {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP}, */
2853         /* {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
2854         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2855
2856         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2857         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
2858
2859         { }
2860 };
2861
2862 /*
2863 * Uniwill P53
2864 * HP = 0x14, InternalSpeaker = 0x15, mic = 0x19,
2865  */
2866 static struct hda_verb alc880_uniwill_p53_init_verbs[] = {
2867         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
2868
2869         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2870         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2871         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2872         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2873         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2874         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2875         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2876         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2877         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2878         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2879         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
2880         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
2881
2882         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2883         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2884         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2885         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2886         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
2887         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2888
2889         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
2890         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_DCVOL_EVENT},
2891
2892         { }
2893 };
2894
2895 static struct hda_verb alc880_beep_init_verbs[] = {
2896         { 0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5) },
2897         { }
2898 };
2899
2900 /* auto-toggle front mic */
2901 static void alc880_uniwill_mic_automute(struct hda_codec *codec)
2902 {
2903         unsigned int present;
2904         unsigned char bits;
2905
2906         present = snd_hda_jack_detect(codec, 0x18);
2907         bits = present ? HDA_AMP_MUTE : 0;
2908         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
2909 }
2910
2911 static void alc880_uniwill_setup(struct hda_codec *codec)
2912 {
2913         struct alc_spec *spec = codec->spec;
2914
2915         spec->autocfg.hp_pins[0] = 0x14;
2916         spec->autocfg.speaker_pins[0] = 0x15;
2917         spec->autocfg.speaker_pins[0] = 0x16;
2918 }
2919
2920 static void alc880_uniwill_init_hook(struct hda_codec *codec)
2921 {
2922         alc_automute_amp(codec);
2923         alc880_uniwill_mic_automute(codec);
2924 }
2925
2926 static void alc880_uniwill_unsol_event(struct hda_codec *codec,
2927                                        unsigned int res)
2928 {
2929         /* Looks like the unsol event is incompatible with the standard
2930          * definition.  4bit tag is placed at 28 bit!
2931          */
2932         switch (res >> 28) {
2933         case ALC880_MIC_EVENT:
2934                 alc880_uniwill_mic_automute(codec);
2935                 break;
2936         default:
2937                 alc_automute_amp_unsol_event(codec, res);
2938                 break;
2939         }
2940 }
2941
2942 static void alc880_uniwill_p53_setup(struct hda_codec *codec)
2943 {
2944         struct alc_spec *spec = codec->spec;
2945
2946         spec->autocfg.hp_pins[0] = 0x14;
2947         spec->autocfg.speaker_pins[0] = 0x15;
2948 }
2949
2950 static void alc880_uniwill_p53_dcvol_automute(struct hda_codec *codec)
2951 {
2952         unsigned int present;
2953
2954         present = snd_hda_codec_read(codec, 0x21, 0,
2955                                      AC_VERB_GET_VOLUME_KNOB_CONTROL, 0);
2956         present &= HDA_AMP_VOLMASK;
2957         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_OUTPUT, 0,
2958                                  HDA_AMP_VOLMASK, present);
2959         snd_hda_codec_amp_stereo(codec, 0x0d, HDA_OUTPUT, 0,
2960                                  HDA_AMP_VOLMASK, present);
2961 }
2962
2963 static void alc880_uniwill_p53_unsol_event(struct hda_codec *codec,
2964                                            unsigned int res)
2965 {
2966         /* Looks like the unsol event is incompatible with the standard
2967          * definition.  4bit tag is placed at 28 bit!
2968          */
2969         if ((res >> 28) == ALC880_DCVOL_EVENT)
2970                 alc880_uniwill_p53_dcvol_automute(codec);
2971         else
2972                 alc_automute_amp_unsol_event(codec, res);
2973 }
2974
2975 /*
2976  * F1734 pin configuration:
2977  * HP = 0x14, speaker-out = 0x15, mic = 0x18
2978  */
2979 static struct hda_verb alc880_pin_f1734_init_verbs[] = {
2980         {0x07, AC_VERB_SET_CONNECT_SEL, 0x01},
2981         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
2982         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
2983         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
2984         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
2985
2986         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
2987         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2988         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2989         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2990
2991         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
2992         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2993         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
2994         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
2995         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2996         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2997         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
2998         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
2999         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3000
3001         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
3002         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_DCVOL_EVENT},
3003
3004         { }
3005 };
3006
3007 /*
3008  * ASUS pin configuration:
3009  * HP/front = 0x14, surr = 0x15, clfe = 0x16, mic = 0x18, line = 0x1a
3010  */
3011 static struct hda_verb alc880_pin_asus_init_verbs[] = {
3012         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02},
3013         {0x11, AC_VERB_SET_CONNECT_SEL, 0x00},
3014         {0x12, AC_VERB_SET_CONNECT_SEL, 0x01},
3015         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00},
3016
3017         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3018         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3020         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3021         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3022         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3023         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3024         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3025
3026         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3027         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3028         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3029         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3030         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3031         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3032         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3033         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3034         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3035
3036         { }
3037 };
3038
3039 /* Enable GPIO mask and set output */
3040 #define alc880_gpio1_init_verbs alc_gpio1_init_verbs
3041 #define alc880_gpio2_init_verbs alc_gpio2_init_verbs
3042 #define alc880_gpio3_init_verbs alc_gpio3_init_verbs
3043
3044 /* Clevo m520g init */
3045 static struct hda_verb alc880_pin_clevo_init_verbs[] = {
3046         /* headphone output */
3047         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3048         /* line-out */
3049         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3050         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3051         /* Line-in */
3052         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3053         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3054         /* CD */
3055         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3056         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3057         /* Mic1 (rear panel) */
3058         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3059         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3060         /* Mic2 (front panel) */
3061         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3062         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3063         /* headphone */
3064         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3065         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3066         /* change to EAPD mode */
3067         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3068         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3069
3070         { }
3071 };
3072
3073 static struct hda_verb alc880_pin_tcl_S700_init_verbs[] = {
3074         /* change to EAPD mode */
3075         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3076         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3077
3078         /* Headphone output */
3079         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3080         /* Front output*/
3081         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3082         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
3083
3084         /* Line In pin widget for input */
3085         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3086         /* CD pin widget for input */
3087         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3088         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3089         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3090
3091         /* change to EAPD mode */
3092         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3093         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
3094
3095         { }
3096 };
3097
3098 /*
3099  * LG m1 express dual
3100  *
3101  * Pin assignment:
3102  *   Rear Line-In/Out (blue): 0x14
3103  *   Build-in Mic-In: 0x15
3104  *   Speaker-out: 0x17
3105  *   HP-Out (green): 0x1b
3106  *   Mic-In/Out (red): 0x19
3107  *   SPDIF-Out: 0x1e
3108  */
3109
3110 /* To make 5.1 output working (green=Front, blue=Surr, red=CLFE) */
3111 static hda_nid_t alc880_lg_dac_nids[3] = {
3112         0x05, 0x02, 0x03
3113 };
3114
3115 /* seems analog CD is not working */
3116 static struct hda_input_mux alc880_lg_capture_source = {
3117         .num_items = 3,
3118         .items = {
3119                 { "Mic", 0x1 },
3120                 { "Line", 0x5 },
3121                 { "Internal Mic", 0x6 },
3122         },
3123 };
3124
3125 /* 2,4,6 channel modes */
3126 static struct hda_verb alc880_lg_ch2_init[] = {
3127         /* set line-in and mic-in to input */
3128         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
3129         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3130         { }
3131 };
3132
3133 static struct hda_verb alc880_lg_ch4_init[] = {
3134         /* set line-in to out and mic-in to input */
3135         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3136         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
3137         { }
3138 };
3139
3140 static struct hda_verb alc880_lg_ch6_init[] = {
3141         /* set line-in and mic-in to output */
3142         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3143         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
3144         { }
3145 };
3146
3147 static struct hda_channel_mode alc880_lg_ch_modes[3] = {
3148         { 2, alc880_lg_ch2_init },
3149         { 4, alc880_lg_ch4_init },
3150         { 6, alc880_lg_ch6_init },
3151 };
3152
3153 static struct snd_kcontrol_new alc880_lg_mixer[] = {
3154         HDA_CODEC_VOLUME("Front Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3155         HDA_BIND_MUTE("Front Playback Switch", 0x0f, 2, HDA_INPUT),
3156         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3157         HDA_BIND_MUTE("Surround Playback Switch", 0x0c, 2, HDA_INPUT),
3158         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0d, 1, 0x0, HDA_OUTPUT),
3159         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
3160         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
3161         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
3162         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3163         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
3164         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x06, HDA_INPUT),
3165         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x06, HDA_INPUT),
3166         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x07, HDA_INPUT),
3167         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x07, HDA_INPUT),
3168         {
3169                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3170                 .name = "Channel Mode",
3171                 .info = alc_ch_mode_info,
3172                 .get = alc_ch_mode_get,
3173                 .put = alc_ch_mode_put,
3174         },
3175         { } /* end */
3176 };
3177
3178 static struct hda_verb alc880_lg_init_verbs[] = {
3179         /* set capture source to mic-in */
3180         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3181         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3182         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
3183         /* mute all amp mixer inputs */
3184         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(5)},
3185         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
3186         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3187         /* line-in to input */
3188         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
3189         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3190         /* built-in mic */
3191         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3192         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3193         /* speaker-out */
3194         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3195         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3196         /* mic-in to input */
3197         {0x11, AC_VERB_SET_CONNECT_SEL, 0x01},
3198         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3199         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3200         /* HP-out */
3201         {0x13, AC_VERB_SET_CONNECT_SEL, 0x03},
3202         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3203         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3204         /* jack sense */
3205         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3206         { }
3207 };
3208
3209 /* toggle speaker-output according to the hp-jack state */
3210 static void alc880_lg_setup(struct hda_codec *codec)
3211 {
3212         struct alc_spec *spec = codec->spec;
3213
3214         spec->autocfg.hp_pins[0] = 0x1b;
3215         spec->autocfg.speaker_pins[0] = 0x17;
3216 }
3217
3218 /*
3219  * LG LW20
3220  *
3221  * Pin assignment:
3222  *   Speaker-out: 0x14
3223  *   Mic-In: 0x18
3224  *   Built-in Mic-In: 0x19
3225  *   Line-In: 0x1b
3226  *   HP-Out: 0x1a
3227  *   SPDIF-Out: 0x1e
3228  */
3229
3230 static struct hda_input_mux alc880_lg_lw_capture_source = {
3231         .num_items = 3,
3232         .items = {
3233                 { "Mic", 0x0 },
3234                 { "Internal Mic", 0x1 },
3235                 { "Line In", 0x2 },
3236         },
3237 };
3238
3239 #define alc880_lg_lw_modes alc880_threestack_modes
3240
3241 static struct snd_kcontrol_new alc880_lg_lw_mixer[] = {
3242         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3243         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3244         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3245         HDA_BIND_MUTE("Surround Playback Switch", 0x0f, 2, HDA_INPUT),
3246         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
3247         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
3248         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
3249         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
3250         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
3251         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
3252         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3253         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3254         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
3255         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
3256         {
3257                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3258                 .name = "Channel Mode",
3259                 .info = alc_ch_mode_info,
3260                 .get = alc_ch_mode_get,
3261                 .put = alc_ch_mode_put,
3262         },
3263         { } /* end */
3264 };
3265
3266 static struct hda_verb alc880_lg_lw_init_verbs[] = {
3267         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3268         {0x10, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
3269         {0x12, AC_VERB_SET_CONNECT_SEL, 0x03}, /* line/surround */
3270
3271         /* set capture source to mic-in */
3272         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3273         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3274         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
3275         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
3276         /* speaker-out */
3277         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3278         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3279         /* HP-out */
3280         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3281         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3282         /* mic-in to input */
3283         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3284         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3285         /* built-in mic */
3286         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3287         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3288         /* jack sense */
3289         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3290         { }
3291 };
3292
3293 /* toggle speaker-output according to the hp-jack state */
3294 static void alc880_lg_lw_setup(struct hda_codec *codec)
3295 {
3296         struct alc_spec *spec = codec->spec;
3297
3298         spec->autocfg.hp_pins[0] = 0x1b;
3299         spec->autocfg.speaker_pins[0] = 0x14;
3300 }
3301
3302 static struct snd_kcontrol_new alc880_medion_rim_mixer[] = {
3303         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3304         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
3305         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
3306         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
3307         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
3308         HDA_CODEC_MUTE("Internal Playback Switch", 0x0b, 0x1, HDA_INPUT),
3309         { } /* end */
3310 };
3311
3312 static struct hda_input_mux alc880_medion_rim_capture_source = {
3313         .num_items = 2,
3314         .items = {
3315                 { "Mic", 0x0 },
3316                 { "Internal Mic", 0x1 },
3317         },
3318 };
3319
3320 static struct hda_verb alc880_medion_rim_init_verbs[] = {
3321         {0x13, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
3322
3323         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3324         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3325
3326         /* Mic1 (rear panel) pin widget for input and vref at 80% */
3327         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
3328         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3329         /* Mic2 (as headphone out) for HP output */
3330         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
3331         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
3332         /* Internal Speaker */
3333         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
3334         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
3335
3336         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
3337         {0x20, AC_VERB_SET_PROC_COEF,  0x3060},
3338
3339         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
3340         { }
3341 };
3342
3343 /* toggle speaker-output according to the hp-jack state */
3344 static void alc880_medion_rim_automute(struct hda_codec *codec)
3345 {
3346         struct alc_spec *spec = codec->spec;
3347         alc_automute_amp(codec);
3348         /* toggle EAPD */
3349         if (spec->jack_present)
3350                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 0);
3351         else
3352                 snd_hda_codec_write(codec, 0x01, 0, AC_VERB_SET_GPIO_DATA, 2);
3353 }
3354
3355 static void alc880_medion_rim_unsol_event(struct hda_codec *codec,
3356                                           unsigned int res)
3357 {
3358         /* Looks like the unsol event is incompatible with the standard
3359          * definition.  4bit tag is placed at 28 bit!
3360          */
3361         if ((res >> 28) == ALC880_HP_EVENT)
3362                 alc880_medion_rim_automute(codec);
3363 }
3364
3365 static void alc880_medion_rim_setup(struct hda_codec *codec)
3366 {
3367         struct alc_spec *spec = codec->spec;
3368
3369         spec->autocfg.hp_pins[0] = 0x14;
3370         spec->autocfg.speaker_pins[0] = 0x1b;
3371 }
3372
3373 #ifdef CONFIG_SND_HDA_POWER_SAVE
3374 static struct hda_amp_list alc880_loopbacks[] = {
3375         { 0x0b, HDA_INPUT, 0 },
3376         { 0x0b, HDA_INPUT, 1 },
3377         { 0x0b, HDA_INPUT, 2 },
3378         { 0x0b, HDA_INPUT, 3 },
3379         { 0x0b, HDA_INPUT, 4 },
3380         { } /* end */
3381 };
3382
3383 static struct hda_amp_list alc880_lg_loopbacks[] = {
3384         { 0x0b, HDA_INPUT, 1 },
3385         { 0x0b, HDA_INPUT, 6 },
3386         { 0x0b, HDA_INPUT, 7 },
3387         { } /* end */
3388 };
3389 #endif
3390
3391 /*
3392  * Common callbacks
3393  */
3394
3395 static int alc_init(struct hda_codec *codec)
3396 {
3397         struct alc_spec *spec = codec->spec;
3398         unsigned int i;
3399
3400         alc_fix_pll(codec);
3401         alc_auto_init_amp(codec, spec->init_amp);
3402
3403         for (i = 0; i < spec->num_init_verbs; i++)
3404                 snd_hda_sequence_write(codec, spec->init_verbs[i]);
3405
3406         if (spec->init_hook)
3407                 spec->init_hook(codec);
3408
3409         return 0;
3410 }
3411
3412 static void alc_unsol_event(struct hda_codec *codec, unsigned int res)
3413 {
3414         struct alc_spec *spec = codec->spec;
3415
3416         if (spec->unsol_event)
3417                 spec->unsol_event(codec, res);
3418 }
3419
3420 #ifdef CONFIG_SND_HDA_POWER_SAVE
3421 static int alc_check_power_status(struct hda_codec *codec, hda_nid_t nid)
3422 {
3423         struct alc_spec *spec = codec->spec;
3424         return snd_hda_check_amp_list_power(codec, &spec->loopback, nid);
3425 }
3426 #endif
3427
3428 /*
3429  * Analog playback callbacks
3430  */
3431 static int alc880_playback_pcm_open(struct hda_pcm_stream *hinfo,
3432                                     struct hda_codec *codec,
3433                                     struct snd_pcm_substream *substream)
3434 {
3435         struct alc_spec *spec = codec->spec;
3436         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
3437                                              hinfo);
3438 }
3439
3440 static int alc880_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3441                                        struct hda_codec *codec,
3442                                        unsigned int stream_tag,
3443                                        unsigned int format,
3444                                        struct snd_pcm_substream *substream)
3445 {
3446         struct alc_spec *spec = codec->spec;
3447         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
3448                                                 stream_tag, format, substream);
3449 }
3450
3451 static int alc880_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3452                                        struct hda_codec *codec,
3453                                        struct snd_pcm_substream *substream)
3454 {
3455         struct alc_spec *spec = codec->spec;
3456         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
3457 }
3458
3459 /*
3460  * Digital out
3461  */
3462 static int alc880_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
3463                                         struct hda_codec *codec,
3464                                         struct snd_pcm_substream *substream)
3465 {
3466         struct alc_spec *spec = codec->spec;
3467         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
3468 }
3469
3470 static int alc880_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
3471                                            struct hda_codec *codec,
3472                                            unsigned int stream_tag,
3473                                            unsigned int format,
3474                                            struct snd_pcm_substream *substream)
3475 {
3476         struct alc_spec *spec = codec->spec;
3477         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout,
3478                                              stream_tag, format, substream);
3479 }
3480
3481 static int alc880_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
3482                                            struct hda_codec *codec,
3483                                            struct snd_pcm_substream *substream)
3484 {
3485         struct alc_spec *spec = codec->spec;
3486         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
3487 }
3488
3489 static int alc880_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
3490                                          struct hda_codec *codec,
3491                                          struct snd_pcm_substream *substream)
3492 {
3493         struct alc_spec *spec = codec->spec;
3494         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
3495 }
3496
3497 /*
3498  * Analog capture
3499  */
3500 static int alc880_alt_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
3501                                       struct hda_codec *codec,
3502                                       unsigned int stream_tag,
3503                                       unsigned int format,
3504                                       struct snd_pcm_substream *substream)
3505 {
3506         struct alc_spec *spec = codec->spec;
3507
3508         snd_hda_codec_setup_stream(codec, spec->adc_nids[substream->number + 1],
3509                                    stream_tag, 0, format);
3510         return 0;
3511 }
3512
3513 static int alc880_alt_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
3514                                       struct hda_codec *codec,
3515                                       struct snd_pcm_substream *substream)
3516 {
3517         struct alc_spec *spec = codec->spec;
3518
3519         snd_hda_codec_cleanup_stream(codec,
3520                                      spec->adc_nids[substream->number + 1]);
3521         return 0;
3522 }
3523
3524
3525 /*
3526  */
3527 static struct hda_pcm_stream alc880_pcm_analog_playback = {
3528         .substreams = 1,
3529         .channels_min = 2,
3530         .channels_max = 8,
3531         /* NID is set in alc_build_pcms */
3532         .ops = {
3533                 .open = alc880_playback_pcm_open,
3534                 .prepare = alc880_playback_pcm_prepare,
3535                 .cleanup = alc880_playback_pcm_cleanup
3536         },
3537 };
3538
3539 static struct hda_pcm_stream alc880_pcm_analog_capture = {
3540         .substreams = 1,
3541         .channels_min = 2,
3542         .channels_max = 2,
3543         /* NID is set in alc_build_pcms */
3544 };
3545
3546 static struct hda_pcm_stream alc880_pcm_analog_alt_playback = {
3547         .substreams = 1,
3548         .channels_min = 2,
3549         .channels_max = 2,
3550         /* NID is set in alc_build_pcms */
3551 };
3552
3553 static struct hda_pcm_stream alc880_pcm_analog_alt_capture = {
3554         .substreams = 2, /* can be overridden */
3555         .channels_min = 2,
3556         .channels_max = 2,
3557         /* NID is set in alc_build_pcms */
3558         .ops = {
3559                 .prepare = alc880_alt_capture_pcm_prepare,
3560                 .cleanup = alc880_alt_capture_pcm_cleanup
3561         },
3562 };
3563
3564 static struct hda_pcm_stream alc880_pcm_digital_playback = {
3565         .substreams = 1,
3566         .channels_min = 2,
3567         .channels_max = 2,
3568         /* NID is set in alc_build_pcms */
3569         .ops = {
3570                 .open = alc880_dig_playback_pcm_open,
3571                 .close = alc880_dig_playback_pcm_close,
3572                 .prepare = alc880_dig_playback_pcm_prepare,
3573                 .cleanup = alc880_dig_playback_pcm_cleanup
3574         },
3575 };
3576
3577 static struct hda_pcm_stream alc880_pcm_digital_capture = {
3578         .substreams = 1,
3579         .channels_min = 2,
3580         .channels_max = 2,
3581         /* NID is set in alc_build_pcms */
3582 };
3583
3584 /* Used by alc_build_pcms to flag that a PCM has no playback stream */
3585 static struct hda_pcm_stream alc_pcm_null_stream = {
3586         .substreams = 0,
3587         .channels_min = 0,
3588         .channels_max = 0,
3589 };
3590
3591 static int alc_build_pcms(struct hda_codec *codec)
3592 {
3593         struct alc_spec *spec = codec->spec;
3594         struct hda_pcm *info = spec->pcm_rec;
3595         int i;
3596
3597         codec->num_pcms = 1;
3598         codec->pcm_info = info;
3599
3600         if (spec->no_analog)
3601                 goto skip_analog;
3602
3603         snprintf(spec->stream_name_analog, sizeof(spec->stream_name_analog),
3604                  "%s Analog", codec->chip_name);
3605         info->name = spec->stream_name_analog;
3606
3607         if (spec->stream_analog_playback) {
3608                 if (snd_BUG_ON(!spec->multiout.dac_nids))
3609                         return -EINVAL;
3610                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_analog_playback);
3611                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dac_nids[0];
3612         }
3613         if (spec->stream_analog_capture) {
3614                 if (snd_BUG_ON(!spec->adc_nids))
3615                         return -EINVAL;
3616                 info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_analog_capture);
3617                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adc_nids[0];
3618         }
3619
3620         if (spec->channel_mode) {
3621                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = 0;
3622                 for (i = 0; i < spec->num_channel_mode; i++) {
3623                         if (spec->channel_mode[i].channels > info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max) {
3624                                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max = spec->channel_mode[i].channels;
3625                         }
3626                 }
3627         }
3628
3629  skip_analog:
3630         /* SPDIF for stream index #1 */
3631         if (spec->multiout.dig_out_nid || spec->dig_in_nid) {
3632                 snprintf(spec->stream_name_digital,
3633                          sizeof(spec->stream_name_digital),
3634                          "%s Digital", codec->chip_name);
3635                 codec->num_pcms = 2;
3636                 codec->slave_dig_outs = spec->multiout.slave_dig_outs;
3637                 info = spec->pcm_rec + 1;
3638                 info->name = spec->stream_name_digital;
3639                 if (spec->dig_out_type)
3640                         info->pcm_type = spec->dig_out_type;
3641                 else
3642                         info->pcm_type = HDA_PCM_TYPE_SPDIF;
3643                 if (spec->multiout.dig_out_nid &&
3644                     spec->stream_digital_playback) {
3645                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = *(spec->stream_digital_playback);
3646                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->multiout.dig_out_nid;
3647                 }
3648                 if (spec->dig_in_nid &&
3649                     spec->stream_digital_capture) {
3650                         info->stream[SNDRV_PCM_STREAM_CAPTURE] = *(spec->stream_digital_capture);
3651                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in_nid;
3652                 }
3653                 /* FIXME: do we need this for all Realtek codec models? */
3654                 codec->spdif_status_reset = 1;
3655         }
3656
3657         if (spec->no_analog)
3658                 return 0;
3659
3660         /* If the use of more than one ADC is requested for the current
3661          * model, configure a second analog capture-only PCM.
3662          */
3663         /* Additional Analaog capture for index #2 */
3664         if ((spec->alt_dac_nid && spec->stream_analog_alt_playback) ||
3665             (spec->num_adc_nids > 1 && spec->stream_analog_alt_capture)) {
3666                 codec->num_pcms = 3;
3667                 info = spec->pcm_rec + 2;
3668                 info->name = spec->stream_name_analog;
3669                 if (spec->alt_dac_nid) {
3670                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3671                                 *spec->stream_analog_alt_playback;
3672                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
3673                                 spec->alt_dac_nid;
3674                 } else {
3675                         info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
3676                                 alc_pcm_null_stream;
3677                         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = 0;
3678                 }
3679                 if (spec->num_adc_nids > 1) {
3680                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3681                                 *spec->stream_analog_alt_capture;
3682                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
3683                                 spec->adc_nids[1];
3684                         info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams =
3685                                 spec->num_adc_nids - 1;
3686                 } else {
3687                         info->stream[SNDRV_PCM_STREAM_CAPTURE] =
3688                                 alc_pcm_null_stream;
3689                         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = 0;
3690                 }
3691         }
3692
3693         return 0;
3694 }
3695
3696 static inline void alc_shutup(struct hda_codec *codec)
3697 {
3698         snd_hda_shutup_pins(codec);
3699 }
3700
3701 static void alc_free_kctls(struct hda_codec *codec)
3702 {
3703         struct alc_spec *spec = codec->spec;
3704
3705         if (spec->kctls.list) {
3706                 struct snd_kcontrol_new *kctl = spec->kctls.list;
3707                 int i;
3708                 for (i = 0; i < spec->kctls.used; i++)
3709                         kfree(kctl[i].name);
3710         }
3711         snd_array_free(&spec->kctls);
3712 }
3713
3714 static void alc_free(struct hda_codec *codec)
3715 {
3716         struct alc_spec *spec = codec->spec;
3717
3718         if (!spec)
3719                 return;
3720
3721         alc_shutup(codec);
3722         alc_free_kctls(codec);
3723         kfree(spec);
3724         snd_hda_detach_beep_device(codec);
3725 }
3726
3727 #ifdef CONFIG_SND_HDA_POWER_SAVE
3728 static void alc_power_eapd(struct hda_codec *codec)
3729 {
3730         /* We currently only handle front, HP */
3731         switch (codec->vendor_id) {
3732         case 0x10ec0260:
3733                 set_eapd(codec, 0x0f, 0);
3734                 set_eapd(codec, 0x10, 0);
3735                 break;
3736         case 0x10ec0262:
3737         case 0x10ec0267:
3738         case 0x10ec0268:
3739         case 0x10ec0269:
3740         case 0x10ec0270:
3741         case 0x10ec0272:
3742         case 0x10ec0660:
3743         case 0x10ec0662:
3744         case 0x10ec0663:
3745         case 0x10ec0862:
3746         case 0x10ec0889:
3747                 set_eapd(codec, 0x14, 0);
3748                 set_eapd(codec, 0x15, 0);
3749                 break;
3750         }
3751 }
3752
3753 static int alc_suspend(struct hda_codec *codec, pm_message_t state)
3754 {
3755         struct alc_spec *spec = codec->spec;
3756         alc_shutup(codec);
3757         if (spec && spec->power_hook)
3758                 spec->power_hook(codec);
3759         return 0;
3760 }
3761 #endif
3762
3763 #ifdef SND_HDA_NEEDS_RESUME
3764 static int alc_resume(struct hda_codec *codec)
3765 {
3766         codec->patch_ops.init(codec);
3767         snd_hda_codec_resume_amp(codec);
3768         snd_hda_codec_resume_cache(codec);
3769         return 0;
3770 }
3771 #endif
3772
3773 /*
3774  */
3775 static struct hda_codec_ops alc_patch_ops = {
3776         .build_controls = alc_build_controls,
3777         .build_pcms = alc_build_pcms,
3778         .init = alc_init,
3779         .free = alc_free,
3780         .unsol_event = alc_unsol_event,
3781 #ifdef SND_HDA_NEEDS_RESUME
3782         .resume = alc_resume,
3783 #endif
3784 #ifdef CONFIG_SND_HDA_POWER_SAVE
3785         .suspend = alc_suspend,
3786         .check_power_status = alc_check_power_status,
3787 #endif
3788         .reboot_notify = alc_shutup,
3789 };
3790
3791
3792 /*
3793  * Test configuration for debugging
3794  *
3795  * Almost all inputs/outputs are enabled.  I/O pins can be configured via
3796  * enum controls.
3797  */
3798 #ifdef CONFIG_SND_DEBUG
3799 static hda_nid_t alc880_test_dac_nids[4] = {
3800         0x02, 0x03, 0x04, 0x05
3801 };
3802
3803 static struct hda_input_mux alc880_test_capture_source = {
3804         .num_items = 7,
3805         .items = {
3806                 { "In-1", 0x0 },
3807                 { "In-2", 0x1 },
3808                 { "In-3", 0x2 },
3809                 { "In-4", 0x3 },
3810                 { "CD", 0x4 },
3811                 { "Front", 0x5 },
3812                 { "Surround", 0x6 },
3813         },
3814 };
3815
3816 static struct hda_channel_mode alc880_test_modes[4] = {
3817         { 2, NULL },
3818         { 4, NULL },
3819         { 6, NULL },
3820         { 8, NULL },
3821 };
3822
3823 static int alc_test_pin_ctl_info(struct snd_kcontrol *kcontrol,
3824                                  struct snd_ctl_elem_info *uinfo)
3825 {
3826         static char *texts[] = {
3827                 "N/A", "Line Out", "HP Out",
3828                 "In Hi-Z", "In 50%", "In Grd", "In 80%", "In 100%"
3829         };
3830         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3831         uinfo->count = 1;
3832         uinfo->value.enumerated.items = 8;
3833         if (uinfo->value.enumerated.item >= 8)
3834                 uinfo->value.enumerated.item = 7;
3835         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3836         return 0;
3837 }
3838
3839 static int alc_test_pin_ctl_get(struct snd_kcontrol *kcontrol,
3840                                 struct snd_ctl_elem_value *ucontrol)
3841 {
3842         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3843         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3844         unsigned int pin_ctl, item = 0;
3845
3846         pin_ctl = snd_hda_codec_read(codec, nid, 0,
3847                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3848         if (pin_ctl & AC_PINCTL_OUT_EN) {
3849                 if (pin_ctl & AC_PINCTL_HP_EN)
3850                         item = 2;
3851                 else
3852                         item = 1;
3853         } else if (pin_ctl & AC_PINCTL_IN_EN) {
3854                 switch (pin_ctl & AC_PINCTL_VREFEN) {
3855                 case AC_PINCTL_VREF_HIZ: item = 3; break;
3856                 case AC_PINCTL_VREF_50:  item = 4; break;
3857                 case AC_PINCTL_VREF_GRD: item = 5; break;
3858                 case AC_PINCTL_VREF_80:  item = 6; break;
3859                 case AC_PINCTL_VREF_100: item = 7; break;
3860                 }
3861         }
3862         ucontrol->value.enumerated.item[0] = item;
3863         return 0;
3864 }
3865
3866 static int alc_test_pin_ctl_put(struct snd_kcontrol *kcontrol,
3867                                 struct snd_ctl_elem_value *ucontrol)
3868 {
3869         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3870         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3871         static unsigned int ctls[] = {
3872                 0, AC_PINCTL_OUT_EN, AC_PINCTL_OUT_EN | AC_PINCTL_HP_EN,
3873                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_HIZ,
3874                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_50,
3875                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_GRD,
3876                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_80,
3877                 AC_PINCTL_IN_EN | AC_PINCTL_VREF_100,
3878         };
3879         unsigned int old_ctl, new_ctl;
3880
3881         old_ctl = snd_hda_codec_read(codec, nid, 0,
3882                                      AC_VERB_GET_PIN_WIDGET_CONTROL, 0);
3883         new_ctl = ctls[ucontrol->value.enumerated.item[0]];
3884         if (old_ctl != new_ctl) {
3885                 int val;
3886                 snd_hda_codec_write_cache(codec, nid, 0,
3887                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
3888                                           new_ctl);
3889                 val = ucontrol->value.enumerated.item[0] >= 3 ?
3890                         HDA_AMP_MUTE : 0;
3891                 snd_hda_codec_amp_stereo(codec, nid, HDA_OUTPUT, 0,
3892                                          HDA_AMP_MUTE, val);
3893                 return 1;
3894         }
3895         return 0;
3896 }
3897
3898 static int alc_test_pin_src_info(struct snd_kcontrol *kcontrol,
3899                                  struct snd_ctl_elem_info *uinfo)
3900 {
3901         static char *texts[] = {
3902                 "Front", "Surround", "CLFE", "Side"
3903         };
3904         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
3905         uinfo->count = 1;
3906         uinfo->value.enumerated.items = 4;
3907         if (uinfo->value.enumerated.item >= 4)
3908                 uinfo->value.enumerated.item = 3;
3909         strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
3910         return 0;
3911 }
3912
3913 static int alc_test_pin_src_get(struct snd_kcontrol *kcontrol,
3914                                 struct snd_ctl_elem_value *ucontrol)
3915 {
3916         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3917         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3918         unsigned int sel;
3919
3920         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0);
3921         ucontrol->value.enumerated.item[0] = sel & 3;
3922         return 0;
3923 }
3924
3925 static int alc_test_pin_src_put(struct snd_kcontrol *kcontrol,
3926                                 struct snd_ctl_elem_value *ucontrol)
3927 {
3928         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
3929         hda_nid_t nid = (hda_nid_t)kcontrol->private_value;
3930         unsigned int sel;
3931
3932         sel = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONNECT_SEL, 0) & 3;
3933         if (ucontrol->value.enumerated.item[0] != sel) {
3934                 sel = ucontrol->value.enumerated.item[0] & 3;
3935                 snd_hda_codec_write_cache(codec, nid, 0,
3936                                           AC_VERB_SET_CONNECT_SEL, sel);
3937                 return 1;
3938         }
3939         return 0;
3940 }
3941
3942 #define PIN_CTL_TEST(xname,nid) {                       \
3943                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3944                         .name = xname,                 \
3945                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3946                         .info = alc_test_pin_ctl_info, \
3947                         .get = alc_test_pin_ctl_get,   \
3948                         .put = alc_test_pin_ctl_put,   \
3949                         .private_value = nid           \
3950                         }
3951
3952 #define PIN_SRC_TEST(xname,nid) {                       \
3953                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,    \
3954                         .name = xname,                 \
3955                         .subdevice = HDA_SUBDEV_NID_FLAG | nid, \
3956                         .info = alc_test_pin_src_info, \
3957                         .get = alc_test_pin_src_get,   \
3958                         .put = alc_test_pin_src_put,   \
3959                         .private_value = nid           \
3960                         }
3961
3962 static struct snd_kcontrol_new alc880_test_mixer[] = {
3963         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
3964         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
3965         HDA_CODEC_VOLUME("CLFE Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
3966         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
3967         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
3968         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
3969         HDA_BIND_MUTE("CLFE Playback Switch", 0x0e, 2, HDA_INPUT),
3970         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
3971         PIN_CTL_TEST("Front Pin Mode", 0x14),
3972         PIN_CTL_TEST("Surround Pin Mode", 0x15),
3973         PIN_CTL_TEST("CLFE Pin Mode", 0x16),
3974         PIN_CTL_TEST("Side Pin Mode", 0x17),
3975         PIN_CTL_TEST("In-1 Pin Mode", 0x18),
3976         PIN_CTL_TEST("In-2 Pin Mode", 0x19),
3977         PIN_CTL_TEST("In-3 Pin Mode", 0x1a),
3978         PIN_CTL_TEST("In-4 Pin Mode", 0x1b),
3979         PIN_SRC_TEST("In-1 Pin Source", 0x18),
3980         PIN_SRC_TEST("In-2 Pin Source", 0x19),
3981         PIN_SRC_TEST("In-3 Pin Source", 0x1a),
3982         PIN_SRC_TEST("In-4 Pin Source", 0x1b),
3983         HDA_CODEC_VOLUME("In-1 Playback Volume", 0x0b, 0x0, HDA_INPUT),
3984         HDA_CODEC_MUTE("In-1 Playback Switch", 0x0b, 0x0, HDA_INPUT),
3985         HDA_CODEC_VOLUME("In-2 Playback Volume", 0x0b, 0x1, HDA_INPUT),
3986         HDA_CODEC_MUTE("In-2 Playback Switch", 0x0b, 0x1, HDA_INPUT),
3987         HDA_CODEC_VOLUME("In-3 Playback Volume", 0x0b, 0x2, HDA_INPUT),
3988         HDA_CODEC_MUTE("In-3 Playback Switch", 0x0b, 0x2, HDA_INPUT),
3989         HDA_CODEC_VOLUME("In-4 Playback Volume", 0x0b, 0x3, HDA_INPUT),
3990         HDA_CODEC_MUTE("In-4 Playback Switch", 0x0b, 0x3, HDA_INPUT),
3991         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x4, HDA_INPUT),
3992         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x4, HDA_INPUT),
3993         {
3994                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
3995                 .name = "Channel Mode",
3996                 .info = alc_ch_mode_info,
3997                 .get = alc_ch_mode_get,
3998                 .put = alc_ch_mode_put,
3999         },
4000         { } /* end */
4001 };
4002
4003 static struct hda_verb alc880_test_init_verbs[] = {
4004         /* Unmute inputs of 0x0c - 0x0f */
4005         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4006         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4007         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4008         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4009         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4010         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4011         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
4012         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
4013         /* Vol output for 0x0c-0x0f */
4014         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4015         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4016         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4017         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
4018         /* Set output pins 0x14-0x17 */
4019         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4020         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4021         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4022         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
4023         /* Unmute output pins 0x14-0x17 */
4024         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4025         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4026         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4027         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
4028         /* Set input pins 0x18-0x1c */
4029         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4030         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
4031         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4032         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4033         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
4034         /* Mute input pins 0x18-0x1b */
4035         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4036         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4037         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4038         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
4039         /* ADC set up */
4040         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4041         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
4042         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4043         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
4044         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4045         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
4046         /* Analog input/passthru */
4047         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
4048         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
4049         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
4050         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
4051         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
4052         { }
4053 };
4054 #endif
4055
4056 /*
4057  */
4058
4059 static const char *alc880_models[ALC880_MODEL_LAST] = {
4060         [ALC880_3ST]            = "3stack",
4061         [ALC880_TCL_S700]       = "tcl",
4062         [ALC880_3ST_DIG]        = "3stack-digout",
4063         [ALC880_CLEVO]          = "clevo",
4064         [ALC880_5ST]            = "5stack",
4065         [ALC880_5ST_DIG]        = "5stack-digout",
4066         [ALC880_W810]           = "w810",
4067         [ALC880_Z71V]           = "z71v",
4068         [ALC880_6ST]            = "6stack",
4069         [ALC880_6ST_DIG]        = "6stack-digout",
4070         [ALC880_ASUS]           = "asus",
4071         [ALC880_ASUS_W1V]       = "asus-w1v",
4072         [ALC880_ASUS_DIG]       = "asus-dig",
4073         [ALC880_ASUS_DIG2]      = "asus-dig2",
4074         [ALC880_UNIWILL_DIG]    = "uniwill",
4075         [ALC880_UNIWILL_P53]    = "uniwill-p53",
4076         [ALC880_FUJITSU]        = "fujitsu",
4077         [ALC880_F1734]          = "F1734",
4078         [ALC880_LG]             = "lg",
4079         [ALC880_LG_LW]          = "lg-lw",
4080         [ALC880_MEDION_RIM]     = "medion",
4081 #ifdef CONFIG_SND_DEBUG
4082         [ALC880_TEST]           = "test",
4083 #endif
4084         [ALC880_AUTO]           = "auto",
4085 };
4086
4087 static struct snd_pci_quirk alc880_cfg_tbl[] = {
4088         SND_PCI_QUIRK(0x1019, 0x0f69, "Coeus G610P", ALC880_W810),
4089         SND_PCI_QUIRK(0x1019, 0xa880, "ECS", ALC880_5ST_DIG),
4090         SND_PCI_QUIRK(0x1019, 0xa884, "Acer APFV", ALC880_6ST),
4091         SND_PCI_QUIRK(0x1025, 0x0070, "ULI", ALC880_3ST_DIG),
4092         SND_PCI_QUIRK(0x1025, 0x0077, "ULI", ALC880_6ST_DIG),
4093         SND_PCI_QUIRK(0x1025, 0x0078, "ULI", ALC880_6ST_DIG),
4094         SND_PCI_QUIRK(0x1025, 0x0087, "ULI", ALC880_6ST_DIG),
4095         SND_PCI_QUIRK(0x1025, 0xe309, "ULI", ALC880_3ST_DIG),
4096         SND_PCI_QUIRK(0x1025, 0xe310, "ULI", ALC880_3ST),
4097         SND_PCI_QUIRK(0x1039, 0x1234, NULL, ALC880_6ST_DIG),
4098         SND_PCI_QUIRK(0x103c, 0x2a09, "HP", ALC880_5ST),
4099         SND_PCI_QUIRK(0x1043, 0x10b3, "ASUS W1V", ALC880_ASUS_W1V),
4100         SND_PCI_QUIRK(0x1043, 0x10c2, "ASUS W6A", ALC880_ASUS_DIG),
4101         SND_PCI_QUIRK(0x1043, 0x10c3, "ASUS Wxx", ALC880_ASUS_DIG),
4102         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS", ALC880_ASUS_DIG),
4103         SND_PCI_QUIRK(0x1043, 0x1123, "ASUS", ALC880_ASUS_DIG),
4104         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS", ALC880_ASUS_DIG),
4105         SND_PCI_QUIRK(0x1043, 0x1964, "ASUS Z71V", ALC880_Z71V),
4106         /* SND_PCI_QUIRK(0x1043, 0x1964, "ASUS", ALC880_ASUS_DIG), */
4107         SND_PCI_QUIRK(0x1043, 0x1973, "ASUS", ALC880_ASUS_DIG),
4108         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS", ALC880_ASUS_DIG),
4109         SND_PCI_QUIRK(0x1043, 0x814e, "ASUS P5GD1 w/SPDIF", ALC880_6ST_DIG),
4110         SND_PCI_QUIRK(0x1043, 0x8181, "ASUS P4GPL", ALC880_ASUS_DIG),
4111         SND_PCI_QUIRK(0x1043, 0x8196, "ASUS P5GD1", ALC880_6ST),
4112         SND_PCI_QUIRK(0x1043, 0x81b4, "ASUS", ALC880_6ST),
4113         SND_PCI_QUIRK_VENDOR(0x1043, "ASUS", ALC880_ASUS), /* default ASUS */
4114         SND_PCI_QUIRK(0x104d, 0x81a0, "Sony", ALC880_3ST),
4115         SND_PCI_QUIRK(0x104d, 0x81d6, "Sony", ALC880_3ST),
4116         SND_PCI_QUIRK(0x107b, 0x3032, "Gateway", ALC880_5ST),
4117         SND_PCI_QUIRK(0x107b, 0x3033, "Gateway", ALC880_5ST),
4118         SND_PCI_QUIRK(0x107b, 0x4039, "Gateway", ALC880_5ST),
4119         SND_PCI_QUIRK(0x1297, 0xc790, "Shuttle ST20G5", ALC880_6ST_DIG),
4120         SND_PCI_QUIRK(0x1458, 0xa102, "Gigabyte K8", ALC880_6ST_DIG),
4121         SND_PCI_QUIRK(0x1462, 0x1150, "MSI", ALC880_6ST_DIG),
4122         SND_PCI_QUIRK(0x1509, 0x925d, "FIC P4M", ALC880_6ST_DIG),
4123         SND_PCI_QUIRK(0x1558, 0x0520, "Clevo m520G", ALC880_CLEVO),
4124         SND_PCI_QUIRK(0x1558, 0x0660, "Clevo m655n", ALC880_CLEVO),
4125         SND_PCI_QUIRK(0x1558, 0x5401, "ASUS", ALC880_ASUS_DIG2),
4126         SND_PCI_QUIRK(0x1565, 0x8202, "Biostar", ALC880_5ST_DIG),
4127         SND_PCI_QUIRK(0x1584, 0x9050, "Uniwill", ALC880_UNIWILL_DIG),
4128         SND_PCI_QUIRK(0x1584, 0x9054, "Uniwlll", ALC880_F1734),
4129         SND_PCI_QUIRK(0x1584, 0x9070, "Uniwill", ALC880_UNIWILL),
4130         SND_PCI_QUIRK(0x1584, 0x9077, "Uniwill P53", ALC880_UNIWILL_P53),
4131         SND_PCI_QUIRK(0x161f, 0x203d, "W810", ALC880_W810),
4132         SND_PCI_QUIRK(0x161f, 0x205d, "Medion Rim 2150", ALC880_MEDION_RIM),
4133         SND_PCI_QUIRK(0x1695, 0x400d, "EPoX", ALC880_5ST_DIG),
4134         SND_PCI_QUIRK(0x1695, 0x4012, "EPox EP-5LDA", ALC880_5ST_DIG),
4135         SND_PCI_QUIRK(0x1734, 0x107c, "FSC F1734", ALC880_F1734),
4136         SND_PCI_QUIRK(0x1734, 0x1094, "FSC Amilo M1451G", ALC880_FUJITSU),
4137         SND_PCI_QUIRK(0x1734, 0x10ac, "FSC", ALC880_UNIWILL),
4138         SND_PCI_QUIRK(0x1734, 0x10b0, "Fujitsu", ALC880_FUJITSU),
4139         SND_PCI_QUIRK(0x1854, 0x0018, "LG LW20", ALC880_LG_LW),
4140         SND_PCI_QUIRK(0x1854, 0x003b, "LG", ALC880_LG),
4141         SND_PCI_QUIRK(0x1854, 0x0068, "LG w1", ALC880_LG),
4142         SND_PCI_QUIRK(0x1854, 0x0077, "LG LW25", ALC880_LG_LW),
4143         SND_PCI_QUIRK(0x19db, 0x4188, "TCL S700", ALC880_TCL_S700),
4144         SND_PCI_QUIRK(0x2668, 0x8086, NULL, ALC880_6ST_DIG), /* broken BIOS */
4145         SND_PCI_QUIRK(0x8086, 0x2668, NULL, ALC880_6ST_DIG),
4146         SND_PCI_QUIRK(0x8086, 0xa100, "Intel mobo", ALC880_5ST_DIG),
4147         SND_PCI_QUIRK(0x8086, 0xd400, "Intel mobo", ALC880_5ST_DIG),
4148         SND_PCI_QUIRK(0x8086, 0xd401, "Intel mobo", ALC880_5ST_DIG),
4149         SND_PCI_QUIRK(0x8086, 0xd402, "Intel mobo", ALC880_3ST_DIG),
4150         SND_PCI_QUIRK(0x8086, 0xe224, "Intel mobo", ALC880_5ST_DIG),
4151         SND_PCI_QUIRK(0x8086, 0xe305, "Intel mobo", ALC880_3ST_DIG),
4152         SND_PCI_QUIRK(0x8086, 0xe308, "Intel mobo", ALC880_3ST_DIG),
4153         SND_PCI_QUIRK(0x8086, 0xe400, "Intel mobo", ALC880_5ST_DIG),
4154         SND_PCI_QUIRK(0x8086, 0xe401, "Intel mobo", ALC880_5ST_DIG),
4155         SND_PCI_QUIRK(0x8086, 0xe402, "Intel mobo", ALC880_5ST_DIG),
4156         /* default Intel */
4157         SND_PCI_QUIRK_VENDOR(0x8086, "Intel mobo", ALC880_3ST),
4158         SND_PCI_QUIRK(0xa0a0, 0x0560, "AOpen i915GMm-HFS", ALC880_5ST_DIG),
4159         SND_PCI_QUIRK(0xe803, 0x1019, NULL, ALC880_6ST_DIG),
4160         {}
4161 };
4162
4163 /*
4164  * ALC880 codec presets
4165  */
4166 static struct alc_config_preset alc880_presets[] = {
4167         [ALC880_3ST] = {
4168                 .mixers = { alc880_three_stack_mixer },
4169                 .init_verbs = { alc880_volume_init_verbs,
4170                                 alc880_pin_3stack_init_verbs },
4171                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4172                 .dac_nids = alc880_dac_nids,
4173                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4174                 .channel_mode = alc880_threestack_modes,
4175                 .need_dac_fix = 1,
4176                 .input_mux = &alc880_capture_source,
4177         },
4178         [ALC880_3ST_DIG] = {
4179                 .mixers = { alc880_three_stack_mixer },
4180                 .init_verbs = { alc880_volume_init_verbs,
4181                                 alc880_pin_3stack_init_verbs },
4182                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4183                 .dac_nids = alc880_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         },
4190         [ALC880_TCL_S700] = {
4191                 .mixers = { alc880_tcl_s700_mixer },
4192                 .init_verbs = { alc880_volume_init_verbs,
4193                                 alc880_pin_tcl_S700_init_verbs,
4194                                 alc880_gpio2_init_verbs },
4195                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4196                 .dac_nids = alc880_dac_nids,
4197                 .adc_nids = alc880_adc_nids_alt, /* FIXME: correct? */
4198                 .num_adc_nids = 1, /* single ADC */
4199                 .hp_nid = 0x03,
4200                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4201                 .channel_mode = alc880_2_jack_modes,
4202                 .input_mux = &alc880_capture_source,
4203         },
4204         [ALC880_5ST] = {
4205                 .mixers = { alc880_three_stack_mixer,
4206                             alc880_five_stack_mixer},
4207                 .init_verbs = { alc880_volume_init_verbs,
4208                                 alc880_pin_5stack_init_verbs },
4209                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4210                 .dac_nids = alc880_dac_nids,
4211                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4212                 .channel_mode = alc880_fivestack_modes,
4213                 .input_mux = &alc880_capture_source,
4214         },
4215         [ALC880_5ST_DIG] = {
4216                 .mixers = { alc880_three_stack_mixer,
4217                             alc880_five_stack_mixer },
4218                 .init_verbs = { alc880_volume_init_verbs,
4219                                 alc880_pin_5stack_init_verbs },
4220                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4221                 .dac_nids = alc880_dac_nids,
4222                 .dig_out_nid = ALC880_DIGOUT_NID,
4223                 .num_channel_mode = ARRAY_SIZE(alc880_fivestack_modes),
4224                 .channel_mode = alc880_fivestack_modes,
4225                 .input_mux = &alc880_capture_source,
4226         },
4227         [ALC880_6ST] = {
4228                 .mixers = { alc880_six_stack_mixer },
4229                 .init_verbs = { alc880_volume_init_verbs,
4230                                 alc880_pin_6stack_init_verbs },
4231                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4232                 .dac_nids = alc880_6st_dac_nids,
4233                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4234                 .channel_mode = alc880_sixstack_modes,
4235                 .input_mux = &alc880_6stack_capture_source,
4236         },
4237         [ALC880_6ST_DIG] = {
4238                 .mixers = { alc880_six_stack_mixer },
4239                 .init_verbs = { alc880_volume_init_verbs,
4240                                 alc880_pin_6stack_init_verbs },
4241                 .num_dacs = ARRAY_SIZE(alc880_6st_dac_nids),
4242                 .dac_nids = alc880_6st_dac_nids,
4243                 .dig_out_nid = ALC880_DIGOUT_NID,
4244                 .num_channel_mode = ARRAY_SIZE(alc880_sixstack_modes),
4245                 .channel_mode = alc880_sixstack_modes,
4246                 .input_mux = &alc880_6stack_capture_source,
4247         },
4248         [ALC880_W810] = {
4249                 .mixers = { alc880_w810_base_mixer },
4250                 .init_verbs = { alc880_volume_init_verbs,
4251                                 alc880_pin_w810_init_verbs,
4252                                 alc880_gpio2_init_verbs },
4253                 .num_dacs = ARRAY_SIZE(alc880_w810_dac_nids),
4254                 .dac_nids = alc880_w810_dac_nids,
4255                 .dig_out_nid = ALC880_DIGOUT_NID,
4256                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4257                 .channel_mode = alc880_w810_modes,
4258                 .input_mux = &alc880_capture_source,
4259         },
4260         [ALC880_Z71V] = {
4261                 .mixers = { alc880_z71v_mixer },
4262                 .init_verbs = { alc880_volume_init_verbs,
4263                                 alc880_pin_z71v_init_verbs },
4264                 .num_dacs = ARRAY_SIZE(alc880_z71v_dac_nids),
4265                 .dac_nids = alc880_z71v_dac_nids,
4266                 .dig_out_nid = ALC880_DIGOUT_NID,
4267                 .hp_nid = 0x03,
4268                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4269                 .channel_mode = alc880_2_jack_modes,
4270                 .input_mux = &alc880_capture_source,
4271         },
4272         [ALC880_F1734] = {
4273                 .mixers = { alc880_f1734_mixer },
4274                 .init_verbs = { alc880_volume_init_verbs,
4275                                 alc880_pin_f1734_init_verbs },
4276                 .num_dacs = ARRAY_SIZE(alc880_f1734_dac_nids),
4277                 .dac_nids = alc880_f1734_dac_nids,
4278                 .hp_nid = 0x02,
4279                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4280                 .channel_mode = alc880_2_jack_modes,
4281                 .input_mux = &alc880_f1734_capture_source,
4282                 .unsol_event = alc880_uniwill_p53_unsol_event,
4283                 .setup = alc880_uniwill_p53_setup,
4284                 .init_hook = alc_automute_amp,
4285         },
4286         [ALC880_ASUS] = {
4287                 .mixers = { alc880_asus_mixer },
4288                 .init_verbs = { alc880_volume_init_verbs,
4289                                 alc880_pin_asus_init_verbs,
4290                                 alc880_gpio1_init_verbs },
4291                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4292                 .dac_nids = alc880_asus_dac_nids,
4293                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4294                 .channel_mode = alc880_asus_modes,
4295                 .need_dac_fix = 1,
4296                 .input_mux = &alc880_capture_source,
4297         },
4298         [ALC880_ASUS_DIG] = {
4299                 .mixers = { alc880_asus_mixer },
4300                 .init_verbs = { alc880_volume_init_verbs,
4301                                 alc880_pin_asus_init_verbs,
4302                                 alc880_gpio1_init_verbs },
4303                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4304                 .dac_nids = alc880_asus_dac_nids,
4305                 .dig_out_nid = ALC880_DIGOUT_NID,
4306                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4307                 .channel_mode = alc880_asus_modes,
4308                 .need_dac_fix = 1,
4309                 .input_mux = &alc880_capture_source,
4310         },
4311         [ALC880_ASUS_DIG2] = {
4312                 .mixers = { alc880_asus_mixer },
4313                 .init_verbs = { alc880_volume_init_verbs,
4314                                 alc880_pin_asus_init_verbs,
4315                                 alc880_gpio2_init_verbs }, /* use GPIO2 */
4316                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4317                 .dac_nids = alc880_asus_dac_nids,
4318                 .dig_out_nid = ALC880_DIGOUT_NID,
4319                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4320                 .channel_mode = alc880_asus_modes,
4321                 .need_dac_fix = 1,
4322                 .input_mux = &alc880_capture_source,
4323         },
4324         [ALC880_ASUS_W1V] = {
4325                 .mixers = { alc880_asus_mixer, alc880_asus_w1v_mixer },
4326                 .init_verbs = { alc880_volume_init_verbs,
4327                                 alc880_pin_asus_init_verbs,
4328                                 alc880_gpio1_init_verbs },
4329                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4330                 .dac_nids = alc880_asus_dac_nids,
4331                 .dig_out_nid = ALC880_DIGOUT_NID,
4332                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4333                 .channel_mode = alc880_asus_modes,
4334                 .need_dac_fix = 1,
4335                 .input_mux = &alc880_capture_source,
4336         },
4337         [ALC880_UNIWILL_DIG] = {
4338                 .mixers = { alc880_asus_mixer },
4339                 .init_verbs = { alc880_volume_init_verbs,
4340                                 alc880_pin_asus_init_verbs },
4341                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4342                 .dac_nids = alc880_asus_dac_nids,
4343                 .dig_out_nid = ALC880_DIGOUT_NID,
4344                 .num_channel_mode = ARRAY_SIZE(alc880_asus_modes),
4345                 .channel_mode = alc880_asus_modes,
4346                 .need_dac_fix = 1,
4347                 .input_mux = &alc880_capture_source,
4348         },
4349         [ALC880_UNIWILL] = {
4350                 .mixers = { alc880_uniwill_mixer },
4351                 .init_verbs = { alc880_volume_init_verbs,
4352                                 alc880_uniwill_init_verbs },
4353                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4354                 .dac_nids = alc880_asus_dac_nids,
4355                 .dig_out_nid = ALC880_DIGOUT_NID,
4356                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4357                 .channel_mode = alc880_threestack_modes,
4358                 .need_dac_fix = 1,
4359                 .input_mux = &alc880_capture_source,
4360                 .unsol_event = alc880_uniwill_unsol_event,
4361                 .setup = alc880_uniwill_setup,
4362                 .init_hook = alc880_uniwill_init_hook,
4363         },
4364         [ALC880_UNIWILL_P53] = {
4365                 .mixers = { alc880_uniwill_p53_mixer },
4366                 .init_verbs = { alc880_volume_init_verbs,
4367                                 alc880_uniwill_p53_init_verbs },
4368                 .num_dacs = ARRAY_SIZE(alc880_asus_dac_nids),
4369                 .dac_nids = alc880_asus_dac_nids,
4370                 .num_channel_mode = ARRAY_SIZE(alc880_w810_modes),
4371                 .channel_mode = alc880_threestack_modes,
4372                 .input_mux = &alc880_capture_source,
4373                 .unsol_event = alc880_uniwill_p53_unsol_event,
4374                 .setup = alc880_uniwill_p53_setup,
4375                 .init_hook = alc_automute_amp,
4376         },
4377         [ALC880_FUJITSU] = {
4378                 .mixers = { alc880_fujitsu_mixer },
4379                 .init_verbs = { alc880_volume_init_verbs,
4380                                 alc880_uniwill_p53_init_verbs,
4381                                 alc880_beep_init_verbs },
4382                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4383                 .dac_nids = alc880_dac_nids,
4384                 .dig_out_nid = ALC880_DIGOUT_NID,
4385                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4386                 .channel_mode = alc880_2_jack_modes,
4387                 .input_mux = &alc880_capture_source,
4388                 .unsol_event = alc880_uniwill_p53_unsol_event,
4389                 .setup = alc880_uniwill_p53_setup,
4390                 .init_hook = alc_automute_amp,
4391         },
4392         [ALC880_CLEVO] = {
4393                 .mixers = { alc880_three_stack_mixer },
4394                 .init_verbs = { alc880_volume_init_verbs,
4395                                 alc880_pin_clevo_init_verbs },
4396                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4397                 .dac_nids = alc880_dac_nids,
4398                 .hp_nid = 0x03,
4399                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
4400                 .channel_mode = alc880_threestack_modes,
4401                 .need_dac_fix = 1,
4402                 .input_mux = &alc880_capture_source,
4403         },
4404         [ALC880_LG] = {
4405                 .mixers = { alc880_lg_mixer },
4406                 .init_verbs = { alc880_volume_init_verbs,
4407                                 alc880_lg_init_verbs },
4408                 .num_dacs = ARRAY_SIZE(alc880_lg_dac_nids),
4409                 .dac_nids = alc880_lg_dac_nids,
4410                 .dig_out_nid = ALC880_DIGOUT_NID,
4411                 .num_channel_mode = ARRAY_SIZE(alc880_lg_ch_modes),
4412                 .channel_mode = alc880_lg_ch_modes,
4413                 .need_dac_fix = 1,
4414                 .input_mux = &alc880_lg_capture_source,
4415                 .unsol_event = alc_automute_amp_unsol_event,
4416                 .setup = alc880_lg_setup,
4417                 .init_hook = alc_automute_amp,
4418 #ifdef CONFIG_SND_HDA_POWER_SAVE
4419                 .loopbacks = alc880_lg_loopbacks,
4420 #endif
4421         },
4422         [ALC880_LG_LW] = {
4423                 .mixers = { alc880_lg_lw_mixer },
4424                 .init_verbs = { alc880_volume_init_verbs,
4425                                 alc880_lg_lw_init_verbs },
4426                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4427                 .dac_nids = alc880_dac_nids,
4428                 .dig_out_nid = ALC880_DIGOUT_NID,
4429                 .num_channel_mode = ARRAY_SIZE(alc880_lg_lw_modes),
4430                 .channel_mode = alc880_lg_lw_modes,
4431                 .input_mux = &alc880_lg_lw_capture_source,
4432                 .unsol_event = alc_automute_amp_unsol_event,
4433                 .setup = alc880_lg_lw_setup,
4434                 .init_hook = alc_automute_amp,
4435         },
4436         [ALC880_MEDION_RIM] = {
4437                 .mixers = { alc880_medion_rim_mixer },
4438                 .init_verbs = { alc880_volume_init_verbs,
4439                                 alc880_medion_rim_init_verbs,
4440                                 alc_gpio2_init_verbs },
4441                 .num_dacs = ARRAY_SIZE(alc880_dac_nids),
4442                 .dac_nids = alc880_dac_nids,
4443                 .dig_out_nid = ALC880_DIGOUT_NID,
4444                 .num_channel_mode = ARRAY_SIZE(alc880_2_jack_modes),
4445                 .channel_mode = alc880_2_jack_modes,
4446                 .input_mux = &alc880_medion_rim_capture_source,
4447                 .unsol_event = alc880_medion_rim_unsol_event,
4448                 .setup = alc880_medion_rim_setup,
4449                 .init_hook = alc880_medion_rim_automute,
4450         },
4451 #ifdef CONFIG_SND_DEBUG
4452         [ALC880_TEST] = {
4453                 .mixers = { alc880_test_mixer },
4454                 .init_verbs = { alc880_test_init_verbs },
4455                 .num_dacs = ARRAY_SIZE(alc880_test_dac_nids),
4456                 .dac_nids = alc880_test_dac_nids,
4457                 .dig_out_nid = ALC880_DIGOUT_NID,
4458                 .num_channel_mode = ARRAY_SIZE(alc880_test_modes),
4459                 .channel_mode = alc880_test_modes,
4460                 .input_mux = &alc880_test_capture_source,
4461         },
4462 #endif
4463 };
4464
4465 /*
4466  * Automatic parse of I/O pins from the BIOS configuration
4467  */
4468
4469 enum {
4470         ALC_CTL_WIDGET_VOL,
4471         ALC_CTL_WIDGET_MUTE,
4472         ALC_CTL_BIND_MUTE,
4473 };
4474 static struct snd_kcontrol_new alc880_control_templates[] = {
4475         HDA_CODEC_VOLUME(NULL, 0, 0, 0),
4476         HDA_CODEC_MUTE(NULL, 0, 0, 0),
4477         HDA_BIND_MUTE(NULL, 0, 0, 0),
4478 };
4479
4480 /* add dynamic controls */
4481 static int add_control(struct alc_spec *spec, int type, const char *name,
4482                        unsigned long val)
4483 {
4484         struct snd_kcontrol_new *knew;
4485
4486         snd_array_init(&spec->kctls, sizeof(*knew), 32);
4487         knew = snd_array_new(&spec->kctls);
4488         if (!knew)
4489                 return -ENOMEM;
4490         *knew = alc880_control_templates[type];
4491         knew->name = kstrdup(name, GFP_KERNEL);
4492         if (!knew->name)
4493                 return -ENOMEM;
4494         if (get_amp_nid_(val))
4495                 knew->subdevice = HDA_SUBDEV_AMP_FLAG;
4496         knew->private_value = val;
4497         return 0;
4498 }
4499
4500 static int add_control_with_pfx(struct alc_spec *spec, int type,
4501                                 const char *pfx, const char *dir,
4502                                 const char *sfx, unsigned long val)
4503 {
4504         char name[32];
4505         snprintf(name, sizeof(name), "%s %s %s", pfx, dir, sfx);
4506         return add_control(spec, type, name, val);
4507 }
4508
4509 #define add_pb_vol_ctrl(spec, type, pfx, val) \
4510         add_control_with_pfx(spec, type, pfx, "Playback", "Volume", val)
4511 #define add_pb_sw_ctrl(spec, type, pfx, val) \
4512         add_control_with_pfx(spec, type, pfx, "Playback", "Switch", val)
4513
4514 #define alc880_is_fixed_pin(nid)        ((nid) >= 0x14 && (nid) <= 0x17)
4515 #define alc880_fixed_pin_idx(nid)       ((nid) - 0x14)
4516 #define alc880_is_multi_pin(nid)        ((nid) >= 0x18)
4517 #define alc880_multi_pin_idx(nid)       ((nid) - 0x18)
4518 #define alc880_idx_to_dac(nid)          ((nid) + 0x02)
4519 #define alc880_dac_to_idx(nid)          ((nid) - 0x02)
4520 #define alc880_idx_to_mixer(nid)        ((nid) + 0x0c)
4521 #define alc880_idx_to_selector(nid)     ((nid) + 0x10)
4522 #define ALC880_PIN_CD_NID               0x1c
4523
4524 /* fill in the dac_nids table from the parsed pin configuration */
4525 static int alc880_auto_fill_dac_nids(struct alc_spec *spec,
4526                                      const struct auto_pin_cfg *cfg)
4527 {
4528         hda_nid_t nid;
4529         int assigned[4];
4530         int i, j;
4531
4532         memset(assigned, 0, sizeof(assigned));
4533         spec->multiout.dac_nids = spec->private_dac_nids;
4534
4535         /* check the pins hardwired to audio widget */
4536         for (i = 0; i < cfg->line_outs; i++) {
4537                 nid = cfg->line_out_pins[i];
4538                 if (alc880_is_fixed_pin(nid)) {
4539                         int idx = alc880_fixed_pin_idx(nid);
4540                         spec->multiout.dac_nids[i] = alc880_idx_to_dac(idx);
4541                         assigned[idx] = 1;
4542                 }
4543         }
4544         /* left pins can be connect to any audio widget */
4545         for (i = 0; i < cfg->line_outs; i++) {
4546                 nid = cfg->line_out_pins[i];
4547                 if (alc880_is_fixed_pin(nid))
4548                         continue;
4549                 /* search for an empty channel */
4550                 for (j = 0; j < cfg->line_outs; j++) {
4551                         if (!assigned[j]) {
4552                                 spec->multiout.dac_nids[i] =
4553                                         alc880_idx_to_dac(j);
4554                                 assigned[j] = 1;
4555                                 break;
4556                         }
4557                 }
4558         }
4559         spec->multiout.num_dacs = cfg->line_outs;
4560         return 0;
4561 }
4562
4563 /* add playback controls from the parsed DAC table */
4564 static int alc880_auto_create_multi_out_ctls(struct alc_spec *spec,
4565                                              const struct auto_pin_cfg *cfg)
4566 {
4567         static const char *chname[4] = {
4568                 "Front", "Surround", NULL /*CLFE*/, "Side"
4569         };
4570         hda_nid_t nid;
4571         int i, err;
4572
4573         for (i = 0; i < cfg->line_outs; i++) {
4574                 if (!spec->multiout.dac_nids[i])
4575                         continue;
4576                 nid = alc880_idx_to_mixer(alc880_dac_to_idx(spec->multiout.dac_nids[i]));
4577                 if (i == 2) {
4578                         /* Center/LFE */
4579                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4580                                               "Center",
4581                                           HDA_COMPOSE_AMP_VAL(nid, 1, 0,
4582                                                               HDA_OUTPUT));
4583                         if (err < 0)
4584                                 return err;
4585                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
4586                                               "LFE",
4587                                           HDA_COMPOSE_AMP_VAL(nid, 2, 0,
4588                                                               HDA_OUTPUT));
4589                         if (err < 0)
4590                                 return err;
4591                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4592                                              "Center",
4593                                           HDA_COMPOSE_AMP_VAL(nid, 1, 2,
4594                                                               HDA_INPUT));
4595                         if (err < 0)
4596                                 return err;
4597                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
4598                                              "LFE",
4599                                           HDA_COMPOSE_AMP_VAL(nid, 2, 2,
4600                                                               HDA_INPUT));
4601                         if (err < 0)
4602                                 return err;
4603                 } else {
4604                         const char *pfx;
4605                         if (cfg->line_outs == 1 &&
4606                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
4607                                 pfx = "Speaker";
4608                         else
4609                                 pfx = chname[i];
4610                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4611                                           HDA_COMPOSE_AMP_VAL(nid, 3, 0,
4612                                                               HDA_OUTPUT));
4613                         if (err < 0)
4614                                 return err;
4615                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4616                                           HDA_COMPOSE_AMP_VAL(nid, 3, 2,
4617                                                               HDA_INPUT));
4618                         if (err < 0)
4619                                 return err;
4620                 }
4621         }
4622         return 0;
4623 }
4624
4625 /* add playback controls for speaker and HP outputs */
4626 static int alc880_auto_create_extra_out(struct alc_spec *spec, hda_nid_t pin,
4627                                         const char *pfx)
4628 {
4629         hda_nid_t nid;
4630         int err;
4631
4632         if (!pin)
4633                 return 0;
4634
4635         if (alc880_is_fixed_pin(pin)) {
4636                 nid = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
4637                 /* specify the DAC as the extra output */
4638                 if (!spec->multiout.hp_nid)
4639                         spec->multiout.hp_nid = nid;
4640                 else
4641                         spec->multiout.extra_out_nid[0] = nid;
4642                 /* control HP volume/switch on the output mixer amp */
4643                 nid = alc880_idx_to_mixer(alc880_fixed_pin_idx(pin));
4644                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
4645                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT));
4646                 if (err < 0)
4647                         return err;
4648                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
4649                                   HDA_COMPOSE_AMP_VAL(nid, 3, 2, HDA_INPUT));
4650                 if (err < 0)
4651                         return err;
4652         } else if (alc880_is_multi_pin(pin)) {
4653                 /* set manual connection */
4654                 /* we have only a switch on HP-out PIN */
4655                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
4656                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
4657                 if (err < 0)
4658                         return err;
4659         }
4660         return 0;
4661 }
4662
4663 /* create input playback/capture controls for the given pin */
4664 static int new_analog_input(struct alc_spec *spec, hda_nid_t pin,
4665                             const char *ctlname,
4666                             int idx, hda_nid_t mix_nid)
4667 {
4668         int err;
4669
4670         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
4671                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4672         if (err < 0)
4673                 return err;
4674         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
4675                           HDA_COMPOSE_AMP_VAL(mix_nid, 3, idx, HDA_INPUT));
4676         if (err < 0)
4677                 return err;
4678         return 0;
4679 }
4680
4681 static int alc_is_input_pin(struct hda_codec *codec, hda_nid_t nid)
4682 {
4683         unsigned int pincap = snd_hda_query_pin_caps(codec, nid);
4684         return (pincap & AC_PINCAP_IN) != 0;
4685 }
4686
4687 /* create playback/capture controls for input pins */
4688 static int alc_auto_create_input_ctls(struct hda_codec *codec,
4689                                       const struct auto_pin_cfg *cfg,
4690                                       hda_nid_t mixer,
4691                                       hda_nid_t cap1, hda_nid_t cap2)
4692 {
4693         struct alc_spec *spec = codec->spec;
4694         struct hda_input_mux *imux = &spec->private_imux[0];
4695         int i, err, idx;
4696
4697         for (i = 0; i < AUTO_PIN_LAST; i++) {
4698                 hda_nid_t pin;
4699
4700                 pin = cfg->input_pins[i];
4701                 if (!alc_is_input_pin(codec, pin))
4702                         continue;
4703
4704                 if (mixer) {
4705                         idx = get_connection_index(codec, mixer, pin);
4706                         if (idx >= 0) {
4707                                 err = new_analog_input(spec, pin,
4708                                                        auto_pin_cfg_labels[i],
4709                                                        idx, mixer);
4710                                 if (err < 0)
4711                                         return err;
4712                         }
4713                 }
4714
4715                 if (!cap1)
4716                         continue;
4717                 idx = get_connection_index(codec, cap1, pin);
4718                 if (idx < 0 && cap2)
4719                         idx = get_connection_index(codec, cap2, pin);
4720                 if (idx >= 0) {
4721                         imux->items[imux->num_items].label =
4722                                 auto_pin_cfg_labels[i];
4723                         imux->items[imux->num_items].index = idx;
4724                         imux->num_items++;
4725                 }
4726         }
4727         return 0;
4728 }
4729
4730 static int alc880_auto_create_input_ctls(struct hda_codec *codec,
4731                                                 const struct auto_pin_cfg *cfg)
4732 {
4733         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x08, 0x09);
4734 }
4735
4736 static void alc_set_pin_output(struct hda_codec *codec, hda_nid_t nid,
4737                                unsigned int pin_type)
4738 {
4739         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
4740                             pin_type);
4741         /* unmute pin */
4742         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_AMP_GAIN_MUTE,
4743                             AMP_OUT_UNMUTE);
4744 }
4745
4746 static void alc880_auto_set_output_and_unmute(struct hda_codec *codec,
4747                                               hda_nid_t nid, int pin_type,
4748                                               int dac_idx)
4749 {
4750         alc_set_pin_output(codec, nid, pin_type);
4751         /* need the manual connection? */
4752         if (alc880_is_multi_pin(nid)) {
4753                 struct alc_spec *spec = codec->spec;
4754                 int idx = alc880_multi_pin_idx(nid);
4755                 snd_hda_codec_write(codec, alc880_idx_to_selector(idx), 0,
4756                                     AC_VERB_SET_CONNECT_SEL,
4757                                     alc880_dac_to_idx(spec->multiout.dac_nids[dac_idx]));
4758         }
4759 }
4760
4761 static int get_pin_type(int line_out_type)
4762 {
4763         if (line_out_type == AUTO_PIN_HP_OUT)
4764                 return PIN_HP;
4765         else
4766                 return PIN_OUT;
4767 }
4768
4769 static void alc880_auto_init_multi_out(struct hda_codec *codec)
4770 {
4771         struct alc_spec *spec = codec->spec;
4772         int i;
4773
4774         for (i = 0; i < spec->autocfg.line_outs; i++) {
4775                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
4776                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
4777                 alc880_auto_set_output_and_unmute(codec, nid, pin_type, i);
4778         }
4779 }
4780
4781 static void alc880_auto_init_extra_out(struct hda_codec *codec)
4782 {
4783         struct alc_spec *spec = codec->spec;
4784         hda_nid_t pin;
4785
4786         pin = spec->autocfg.speaker_pins[0];
4787         if (pin) /* connect to front */
4788                 alc880_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
4789         pin = spec->autocfg.hp_pins[0];
4790         if (pin) /* connect to front */
4791                 alc880_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
4792 }
4793
4794 static void alc880_auto_init_analog_input(struct hda_codec *codec)
4795 {
4796         struct alc_spec *spec = codec->spec;
4797         int i;
4798
4799         for (i = 0; i < AUTO_PIN_LAST; i++) {
4800                 hda_nid_t nid = spec->autocfg.input_pins[i];
4801                 if (alc_is_input_pin(codec, nid)) {
4802                         alc_set_input_pin(codec, nid, i);
4803                         if (nid != ALC880_PIN_CD_NID &&
4804                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
4805                                 snd_hda_codec_write(codec, nid, 0,
4806                                                     AC_VERB_SET_AMP_GAIN_MUTE,
4807                                                     AMP_OUT_MUTE);
4808                 }
4809         }
4810 }
4811
4812 /* parse the BIOS configuration and set up the alc_spec */
4813 /* return 1 if successful, 0 if the proper config is not found,
4814  * or a negative error code
4815  */
4816 static int alc880_parse_auto_config(struct hda_codec *codec)
4817 {
4818         struct alc_spec *spec = codec->spec;
4819         int i, err;
4820         static hda_nid_t alc880_ignore[] = { 0x1d, 0 };
4821
4822         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
4823                                            alc880_ignore);
4824         if (err < 0)
4825                 return err;
4826         if (!spec->autocfg.line_outs)
4827                 return 0; /* can't find valid BIOS pin config */
4828
4829         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
4830         if (err < 0)
4831                 return err;
4832         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
4833         if (err < 0)
4834                 return err;
4835         err = alc880_auto_create_extra_out(spec,
4836                                            spec->autocfg.speaker_pins[0],
4837                                            "Speaker");
4838         if (err < 0)
4839                 return err;
4840         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
4841                                            "Headphone");
4842         if (err < 0)
4843                 return err;
4844         err = alc880_auto_create_input_ctls(codec, &spec->autocfg);
4845         if (err < 0)
4846                 return err;
4847
4848         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
4849
4850         /* check multiple SPDIF-out (for recent codecs) */
4851         for (i = 0; i < spec->autocfg.dig_outs; i++) {
4852                 hda_nid_t dig_nid;
4853                 err = snd_hda_get_connections(codec,
4854                                               spec->autocfg.dig_out_pins[i],
4855                                               &dig_nid, 1);
4856                 if (err < 0)
4857                         continue;
4858                 if (!i)
4859                         spec->multiout.dig_out_nid = dig_nid;
4860                 else {
4861                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
4862                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
4863                                 break;
4864                         spec->slave_dig_outs[i - 1] = dig_nid;
4865                 }
4866         }
4867         if (spec->autocfg.dig_in_pin)
4868                 spec->dig_in_nid = ALC880_DIGIN_NID;
4869
4870         if (spec->kctls.list)
4871                 add_mixer(spec, spec->kctls.list);
4872
4873         add_verb(spec, alc880_volume_init_verbs);
4874
4875         spec->num_mux_defs = 1;
4876         spec->input_mux = &spec->private_imux[0];
4877
4878         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
4879
4880         return 1;
4881 }
4882
4883 /* additional initialization for auto-configuration model */
4884 static void alc880_auto_init(struct hda_codec *codec)
4885 {
4886         struct alc_spec *spec = codec->spec;
4887         alc880_auto_init_multi_out(codec);
4888         alc880_auto_init_extra_out(codec);
4889         alc880_auto_init_analog_input(codec);
4890         if (spec->unsol_event)
4891                 alc_inithook(codec);
4892 }
4893
4894 /* check the ADC/MUX contains all input pins; some ADC/MUX contains only
4895  * one of two digital mic pins, e.g. on ALC272
4896  */
4897 static void fixup_automic_adc(struct hda_codec *codec)
4898 {
4899         struct alc_spec *spec = codec->spec;
4900         int i;
4901
4902         for (i = 0; i < spec->num_adc_nids; i++) {
4903                 hda_nid_t cap = spec->capsrc_nids ?
4904                         spec->capsrc_nids[i] : spec->adc_nids[i];
4905                 int iidx, eidx;
4906
4907                 iidx = get_connection_index(codec, cap, spec->int_mic.pin);
4908                 if (iidx < 0)
4909                         continue;
4910                 eidx = get_connection_index(codec, cap, spec->ext_mic.pin);
4911                 if (eidx < 0)
4912                         continue;
4913                 spec->int_mic.mux_idx = iidx;
4914                 spec->ext_mic.mux_idx = eidx;
4915                 if (spec->capsrc_nids)
4916                         spec->capsrc_nids += i;
4917                 spec->adc_nids += i;
4918                 spec->num_adc_nids = 1;
4919                 return;
4920         }
4921         snd_printd(KERN_INFO "hda_codec: %s: "
4922                    "No ADC/MUX containing both 0x%x and 0x%x pins\n",
4923                    codec->chip_name, spec->int_mic.pin, spec->ext_mic.pin);
4924         spec->auto_mic = 0; /* disable auto-mic to be sure */
4925 }
4926
4927 /* choose the ADC/MUX containing the input pin and initialize the setup */
4928 static void fixup_single_adc(struct hda_codec *codec)
4929 {
4930         struct alc_spec *spec = codec->spec;
4931         hda_nid_t pin = 0;
4932         int i;
4933
4934         /* search for the input pin; there must be only one */
4935         for (i = 0; i < AUTO_PIN_LAST; i++) {
4936                 if (spec->autocfg.input_pins[i]) {
4937                         pin = spec->autocfg.input_pins[i];
4938                         break;
4939                 }
4940         }
4941         if (!pin)
4942                 return;
4943
4944         /* set the default connection to that pin */
4945         for (i = 0; i < spec->num_adc_nids; i++) {
4946                 hda_nid_t cap = spec->capsrc_nids ?
4947                         spec->capsrc_nids[i] : spec->adc_nids[i];
4948                 int idx;
4949
4950                 idx = get_connection_index(codec, cap, pin);
4951                 if (idx < 0)
4952                         continue;
4953                 /* use only this ADC */
4954                 if (spec->capsrc_nids)
4955                         spec->capsrc_nids += i;
4956                 spec->adc_nids += i;
4957                 spec->num_adc_nids = 1;
4958                 /* select or unmute this route */
4959                 if (get_wcaps_type(get_wcaps(codec, cap)) == AC_WID_AUD_MIX) {
4960                         snd_hda_codec_amp_stereo(codec, cap, HDA_INPUT, idx,
4961                                                  HDA_AMP_MUTE, 0);
4962                 } else {
4963                         snd_hda_codec_write_cache(codec, cap, 0,
4964                                           AC_VERB_SET_CONNECT_SEL, idx);
4965                 }
4966                 return;
4967         }
4968 }
4969
4970 static void set_capture_mixer(struct hda_codec *codec)
4971 {
4972         struct alc_spec *spec = codec->spec;
4973         static struct snd_kcontrol_new *caps[2][3] = {
4974                 { alc_capture_mixer_nosrc1,
4975                   alc_capture_mixer_nosrc2,
4976                   alc_capture_mixer_nosrc3 },
4977                 { alc_capture_mixer1,
4978                   alc_capture_mixer2,
4979                   alc_capture_mixer3 },
4980         };
4981         if (spec->num_adc_nids > 0 && spec->num_adc_nids <= 3) {
4982                 int mux = 0;
4983                 if (spec->auto_mic)
4984                         fixup_automic_adc(codec);
4985                 else if (spec->input_mux) {
4986                         if (spec->input_mux->num_items > 1)
4987                                 mux = 1;
4988                         else if (spec->input_mux->num_items == 1)
4989                                 fixup_single_adc(codec);
4990                 }
4991                 spec->cap_mixer = caps[mux][spec->num_adc_nids - 1];
4992         }
4993 }
4994
4995 /* fill adc_nids (and capsrc_nids) containing all active input pins */
4996 static void fillup_priv_adc_nids(struct hda_codec *codec, hda_nid_t *nids,
4997                                  int num_nids)
4998 {
4999         struct alc_spec *spec = codec->spec;
5000         int n;
5001         hda_nid_t fallback_adc = 0, fallback_cap = 0;
5002
5003         for (n = 0; n < num_nids; n++) {
5004                 hda_nid_t adc, cap;
5005                 hda_nid_t conn[HDA_MAX_NUM_INPUTS];
5006                 int nconns, i, j;
5007
5008                 adc = nids[n];
5009                 if (get_wcaps_type(get_wcaps(codec, adc)) != AC_WID_AUD_IN)
5010                         continue;
5011                 cap = adc;
5012                 nconns = snd_hda_get_connections(codec, cap, conn,
5013                                                  ARRAY_SIZE(conn));
5014                 if (nconns == 1) {
5015                         cap = conn[0];
5016                         nconns = snd_hda_get_connections(codec, cap, conn,
5017                                                          ARRAY_SIZE(conn));
5018                 }
5019                 if (nconns <= 0)
5020                         continue;
5021                 if (!fallback_adc) {
5022                         fallback_adc = adc;
5023                         fallback_cap = cap;
5024                 }
5025                 for (i = 0; i < AUTO_PIN_LAST; i++) {
5026                         hda_nid_t nid = spec->autocfg.input_pins[i];
5027                         if (!nid)
5028                                 continue;
5029                         for (j = 0; j < nconns; j++) {
5030                                 if (conn[j] == nid)
5031                                         break;
5032                         }
5033                         if (j >= nconns)
5034                                 break;
5035                 }
5036                 if (i >= AUTO_PIN_LAST) {
5037                         int num_adcs = spec->num_adc_nids;
5038                         spec->private_adc_nids[num_adcs] = adc;
5039                         spec->private_capsrc_nids[num_adcs] = cap;
5040                         spec->num_adc_nids++;
5041                         spec->adc_nids = spec->private_adc_nids;
5042                         if (adc != cap)
5043                                 spec->capsrc_nids = spec->private_capsrc_nids;
5044                 }
5045         }
5046         if (!spec->num_adc_nids) {
5047                 printk(KERN_WARNING "hda_codec: %s: no valid ADC found;"
5048                        " using fallback 0x%x\n",
5049                        codec->chip_name, fallback_adc);
5050                 spec->private_adc_nids[0] = fallback_adc;
5051                 spec->adc_nids = spec->private_adc_nids;
5052                 if (fallback_adc != fallback_cap) {
5053                         spec->private_capsrc_nids[0] = fallback_cap;
5054                         spec->capsrc_nids = spec->private_adc_nids;
5055                 }
5056         }
5057 }
5058
5059 #ifdef CONFIG_SND_HDA_INPUT_BEEP
5060 #define set_beep_amp(spec, nid, idx, dir) \
5061         ((spec)->beep_amp = HDA_COMPOSE_AMP_VAL(nid, 3, idx, dir))
5062 #else
5063 #define set_beep_amp(spec, nid, idx, dir) /* NOP */
5064 #endif
5065
5066 /*
5067  * OK, here we have finally the patch for ALC880
5068  */
5069
5070 static int patch_alc880(struct hda_codec *codec)
5071 {
5072         struct alc_spec *spec;
5073         int board_config;
5074         int err;
5075
5076         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
5077         if (spec == NULL)
5078                 return -ENOMEM;
5079
5080         codec->spec = spec;
5081
5082         board_config = snd_hda_check_board_config(codec, ALC880_MODEL_LAST,
5083                                                   alc880_models,
5084                                                   alc880_cfg_tbl);
5085         if (board_config < 0) {
5086                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
5087                        codec->chip_name);
5088                 board_config = ALC880_AUTO;
5089         }
5090
5091         if (board_config == ALC880_AUTO) {
5092                 /* automatic parse from the BIOS config */
5093                 err = alc880_parse_auto_config(codec);
5094                 if (err < 0) {
5095                         alc_free(codec);
5096                         return err;
5097                 } else if (!err) {
5098                         printk(KERN_INFO
5099                                "hda_codec: Cannot set up configuration "
5100                                "from BIOS.  Using 3-stack mode...\n");
5101                         board_config = ALC880_3ST;
5102                 }
5103         }
5104
5105         err = snd_hda_attach_beep_device(codec, 0x1);
5106         if (err < 0) {
5107                 alc_free(codec);
5108                 return err;
5109         }
5110
5111         if (board_config != ALC880_AUTO)
5112                 setup_preset(codec, &alc880_presets[board_config]);
5113
5114         spec->stream_analog_playback = &alc880_pcm_analog_playback;
5115         spec->stream_analog_capture = &alc880_pcm_analog_capture;
5116         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
5117
5118         spec->stream_digital_playback = &alc880_pcm_digital_playback;
5119         spec->stream_digital_capture = &alc880_pcm_digital_capture;
5120
5121         if (!spec->adc_nids && spec->input_mux) {
5122                 /* check whether NID 0x07 is valid */
5123                 unsigned int wcap = get_wcaps(codec, alc880_adc_nids[0]);
5124                 /* get type */
5125                 wcap = get_wcaps_type(wcap);
5126                 if (wcap != AC_WID_AUD_IN) {
5127                         spec->adc_nids = alc880_adc_nids_alt;
5128                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids_alt);
5129                 } else {
5130                         spec->adc_nids = alc880_adc_nids;
5131                         spec->num_adc_nids = ARRAY_SIZE(alc880_adc_nids);
5132                 }
5133         }
5134         set_capture_mixer(codec);
5135         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
5136
5137         spec->vmaster_nid = 0x0c;
5138
5139         codec->patch_ops = alc_patch_ops;
5140         if (board_config == ALC880_AUTO)
5141                 spec->init_hook = alc880_auto_init;
5142 #ifdef CONFIG_SND_HDA_POWER_SAVE
5143         if (!spec->loopback.amplist)
5144                 spec->loopback.amplist = alc880_loopbacks;
5145 #endif
5146
5147         return 0;
5148 }
5149
5150
5151 /*
5152  * ALC260 support
5153  */
5154
5155 static hda_nid_t alc260_dac_nids[1] = {
5156         /* front */
5157         0x02,
5158 };
5159
5160 static hda_nid_t alc260_adc_nids[1] = {
5161         /* ADC0 */
5162         0x04,
5163 };
5164
5165 static hda_nid_t alc260_adc_nids_alt[1] = {
5166         /* ADC1 */
5167         0x05,
5168 };
5169
5170 /* NIDs used when simultaneous access to both ADCs makes sense.  Note that
5171  * alc260_capture_mixer assumes ADC0 (nid 0x04) is the first ADC.
5172  */
5173 static hda_nid_t alc260_dual_adc_nids[2] = {
5174         /* ADC0, ADC1 */
5175         0x04, 0x05
5176 };
5177
5178 #define ALC260_DIGOUT_NID       0x03
5179 #define ALC260_DIGIN_NID        0x06
5180
5181 static struct hda_input_mux alc260_capture_source = {
5182         .num_items = 4,
5183         .items = {
5184                 { "Mic", 0x0 },
5185                 { "Front Mic", 0x1 },
5186                 { "Line", 0x2 },
5187                 { "CD", 0x4 },
5188         },
5189 };
5190
5191 /* On Fujitsu S702x laptops capture only makes sense from Mic/LineIn jack,
5192  * headphone jack and the internal CD lines since these are the only pins at
5193  * which audio can appear.  For flexibility, also allow the option of
5194  * recording the mixer output on the second ADC (ADC0 doesn't have a
5195  * connection to the mixer output).
5196  */
5197 static struct hda_input_mux alc260_fujitsu_capture_sources[2] = {
5198         {
5199                 .num_items = 3,
5200                 .items = {
5201                         { "Mic/Line", 0x0 },
5202                         { "CD", 0x4 },
5203                         { "Headphone", 0x2 },
5204                 },
5205         },
5206         {
5207                 .num_items = 4,
5208                 .items = {
5209                         { "Mic/Line", 0x0 },
5210                         { "CD", 0x4 },
5211                         { "Headphone", 0x2 },
5212                         { "Mixer", 0x5 },
5213                 },
5214         },
5215
5216 };
5217
5218 /* Acer TravelMate(/Extensa/Aspire) notebooks have similar configuration to
5219  * the Fujitsu S702x, but jacks are marked differently.
5220  */
5221 static struct hda_input_mux alc260_acer_capture_sources[2] = {
5222         {
5223                 .num_items = 4,
5224                 .items = {
5225                         { "Mic", 0x0 },
5226                         { "Line", 0x2 },
5227                         { "CD", 0x4 },
5228                         { "Headphone", 0x5 },
5229                 },
5230         },
5231         {
5232                 .num_items = 5,
5233                 .items = {
5234                         { "Mic", 0x0 },
5235                         { "Line", 0x2 },
5236                         { "CD", 0x4 },
5237                         { "Headphone", 0x6 },
5238                         { "Mixer", 0x5 },
5239                 },
5240         },
5241 };
5242
5243 /* Maxdata Favorit 100XS */
5244 static struct hda_input_mux alc260_favorit100_capture_sources[2] = {
5245         {
5246                 .num_items = 2,
5247                 .items = {
5248                         { "Line/Mic", 0x0 },
5249                         { "CD", 0x4 },
5250                 },
5251         },
5252         {
5253                 .num_items = 3,
5254                 .items = {
5255                         { "Line/Mic", 0x0 },
5256                         { "CD", 0x4 },
5257                         { "Mixer", 0x5 },
5258                 },
5259         },
5260 };
5261
5262 /*
5263  * This is just place-holder, so there's something for alc_build_pcms to look
5264  * at when it calculates the maximum number of channels. ALC260 has no mixer
5265  * element which allows changing the channel mode, so the verb list is
5266  * never used.
5267  */
5268 static struct hda_channel_mode alc260_modes[1] = {
5269         { 2, NULL },
5270 };
5271
5272
5273 /* Mixer combinations
5274  *
5275  * basic: base_output + input + pc_beep + capture
5276  * HP: base_output + input + capture_alt
5277  * HP_3013: hp_3013 + input + capture
5278  * fujitsu: fujitsu + capture
5279  * acer: acer + capture
5280  */
5281
5282 static struct snd_kcontrol_new alc260_base_output_mixer[] = {
5283         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5284         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5285         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5286         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5287         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5288         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5289         { } /* end */
5290 };
5291
5292 static struct snd_kcontrol_new alc260_input_mixer[] = {
5293         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5294         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5295         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5296         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5297         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5298         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5299         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x07, 0x01, HDA_INPUT),
5300         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x07, 0x01, HDA_INPUT),
5301         { } /* end */
5302 };
5303
5304 /* update HP, line and mono out pins according to the master switch */
5305 static void alc260_hp_master_update(struct hda_codec *codec,
5306                                     hda_nid_t hp, hda_nid_t line,
5307                                     hda_nid_t mono)
5308 {
5309         struct alc_spec *spec = codec->spec;
5310         unsigned int val = spec->master_sw ? PIN_HP : 0;
5311         /* change HP and line-out pins */
5312         snd_hda_codec_write(codec, hp, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5313                             val);
5314         snd_hda_codec_write(codec, line, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5315                             val);
5316         /* mono (speaker) depending on the HP jack sense */
5317         val = (val && !spec->jack_present) ? PIN_OUT : 0;
5318         snd_hda_codec_write(codec, mono, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5319                             val);
5320 }
5321
5322 static int alc260_hp_master_sw_get(struct snd_kcontrol *kcontrol,
5323                                    struct snd_ctl_elem_value *ucontrol)
5324 {
5325         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5326         struct alc_spec *spec = codec->spec;
5327         *ucontrol->value.integer.value = spec->master_sw;
5328         return 0;
5329 }
5330
5331 static int alc260_hp_master_sw_put(struct snd_kcontrol *kcontrol,
5332                                    struct snd_ctl_elem_value *ucontrol)
5333 {
5334         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
5335         struct alc_spec *spec = codec->spec;
5336         int val = !!*ucontrol->value.integer.value;
5337         hda_nid_t hp, line, mono;
5338
5339         if (val == spec->master_sw)
5340                 return 0;
5341         spec->master_sw = val;
5342         hp = (kcontrol->private_value >> 16) & 0xff;
5343         line = (kcontrol->private_value >> 8) & 0xff;
5344         mono = kcontrol->private_value & 0xff;
5345         alc260_hp_master_update(codec, hp, line, mono);
5346         return 1;
5347 }
5348
5349 static struct snd_kcontrol_new alc260_hp_output_mixer[] = {
5350         {
5351                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5352                 .name = "Master Playback Switch",
5353                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5354                 .info = snd_ctl_boolean_mono_info,
5355                 .get = alc260_hp_master_sw_get,
5356                 .put = alc260_hp_master_sw_put,
5357                 .private_value = (0x0f << 16) | (0x10 << 8) | 0x11
5358         },
5359         HDA_CODEC_VOLUME("Front Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5360         HDA_BIND_MUTE("Front Playback Switch", 0x08, 2, HDA_INPUT),
5361         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5362         HDA_BIND_MUTE("Headphone Playback Switch", 0x09, 2, HDA_INPUT),
5363         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5364                               HDA_OUTPUT),
5365         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2, HDA_INPUT),
5366         { } /* end */
5367 };
5368
5369 static struct hda_verb alc260_hp_unsol_verbs[] = {
5370         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5371         {},
5372 };
5373
5374 static void alc260_hp_automute(struct hda_codec *codec)
5375 {
5376         struct alc_spec *spec = codec->spec;
5377
5378         spec->jack_present = snd_hda_jack_detect(codec, 0x10);
5379         alc260_hp_master_update(codec, 0x0f, 0x10, 0x11);
5380 }
5381
5382 static void alc260_hp_unsol_event(struct hda_codec *codec, unsigned int res)
5383 {
5384         if ((res >> 26) == ALC880_HP_EVENT)
5385                 alc260_hp_automute(codec);
5386 }
5387
5388 static struct snd_kcontrol_new alc260_hp_3013_mixer[] = {
5389         {
5390                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
5391                 .name = "Master Playback Switch",
5392                 .subdevice = HDA_SUBDEV_NID_FLAG | 0x11,
5393                 .info = snd_ctl_boolean_mono_info,
5394                 .get = alc260_hp_master_sw_get,
5395                 .put = alc260_hp_master_sw_put,
5396                 .private_value = (0x15 << 16) | (0x10 << 8) | 0x11
5397         },
5398         HDA_CODEC_VOLUME("Front Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5399         HDA_CODEC_MUTE("Front Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5400         HDA_CODEC_VOLUME("Aux-In Playback Volume", 0x07, 0x06, HDA_INPUT),
5401         HDA_CODEC_MUTE("Aux-In Playback Switch", 0x07, 0x06, HDA_INPUT),
5402         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5403         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
5404         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
5405         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x11, 1, 0x0, HDA_OUTPUT),
5406         { } /* end */
5407 };
5408
5409 static struct hda_bind_ctls alc260_dc7600_bind_master_vol = {
5410         .ops = &snd_hda_bind_vol,
5411         .values = {
5412                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_OUTPUT),
5413                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_OUTPUT),
5414                 HDA_COMPOSE_AMP_VAL(0x0a, 3, 0, HDA_OUTPUT),
5415                 0
5416         },
5417 };
5418
5419 static struct hda_bind_ctls alc260_dc7600_bind_switch = {
5420         .ops = &snd_hda_bind_sw,
5421         .values = {
5422                 HDA_COMPOSE_AMP_VAL(0x11, 3, 0, HDA_OUTPUT),
5423                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
5424                 0
5425         },
5426 };
5427
5428 static struct snd_kcontrol_new alc260_hp_dc7600_mixer[] = {
5429         HDA_BIND_VOL("Master Playback Volume", &alc260_dc7600_bind_master_vol),
5430         HDA_BIND_SW("LineOut Playback Switch", &alc260_dc7600_bind_switch),
5431         HDA_CODEC_MUTE("Speaker Playback Switch", 0x0f, 0x0, HDA_OUTPUT),
5432         HDA_CODEC_MUTE("Headphone Playback Switch", 0x10, 0x0, HDA_OUTPUT),
5433         { } /* end */
5434 };
5435
5436 static struct hda_verb alc260_hp_3013_unsol_verbs[] = {
5437         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
5438         {},
5439 };
5440
5441 static void alc260_hp_3013_automute(struct hda_codec *codec)
5442 {
5443         struct alc_spec *spec = codec->spec;
5444
5445         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
5446         alc260_hp_master_update(codec, 0x15, 0x10, 0x11);
5447 }
5448
5449 static void alc260_hp_3013_unsol_event(struct hda_codec *codec,
5450                                        unsigned int res)
5451 {
5452         if ((res >> 26) == ALC880_HP_EVENT)
5453                 alc260_hp_3013_automute(codec);
5454 }
5455
5456 static void alc260_hp_3012_automute(struct hda_codec *codec)
5457 {
5458         unsigned int bits = snd_hda_jack_detect(codec, 0x10) ? 0 : PIN_OUT;
5459
5460         snd_hda_codec_write(codec, 0x0f, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5461                             bits);
5462         snd_hda_codec_write(codec, 0x11, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5463                             bits);
5464         snd_hda_codec_write(codec, 0x15, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
5465                             bits);
5466 }
5467
5468 static void alc260_hp_3012_unsol_event(struct hda_codec *codec,
5469                                        unsigned int res)
5470 {
5471         if ((res >> 26) == ALC880_HP_EVENT)
5472                 alc260_hp_3012_automute(codec);
5473 }
5474
5475 /* Fujitsu S702x series laptops.  ALC260 pin usage: Mic/Line jack = 0x12,
5476  * HP jack = 0x14, CD audio =  0x16, internal speaker = 0x10.
5477  */
5478 static struct snd_kcontrol_new alc260_fujitsu_mixer[] = {
5479         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5480         HDA_BIND_MUTE("Headphone Playback Switch", 0x08, 2, HDA_INPUT),
5481         ALC_PIN_MODE("Headphone Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5482         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5483         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5484         HDA_CODEC_VOLUME("Mic/Line Playback Volume", 0x07, 0x0, HDA_INPUT),
5485         HDA_CODEC_MUTE("Mic/Line Playback Switch", 0x07, 0x0, HDA_INPUT),
5486         ALC_PIN_MODE("Mic/Line Jack Mode", 0x12, ALC_PIN_DIR_IN),
5487         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x09, 0x0, HDA_OUTPUT),
5488         HDA_BIND_MUTE("Speaker Playback Switch", 0x09, 2, HDA_INPUT),
5489         { } /* end */
5490 };
5491
5492 /* Mixer for Acer TravelMate(/Extensa/Aspire) notebooks.  Note that current
5493  * versions of the ALC260 don't act on requests to enable mic bias from NID
5494  * 0x0f (used to drive the headphone jack in these laptops).  The ALC260
5495  * datasheet doesn't mention this restriction.  At this stage it's not clear
5496  * whether this behaviour is intentional or is a hardware bug in chip
5497  * revisions available in early 2006.  Therefore for now allow the
5498  * "Headphone Jack Mode" control to span all choices, but if it turns out
5499  * that the lack of mic bias for this NID is intentional we could change the
5500  * mode from ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
5501  *
5502  * In addition, Acer TravelMate(/Extensa/Aspire) notebooks in early 2006
5503  * don't appear to make the mic bias available from the "line" jack, even
5504  * though the NID used for this jack (0x14) can supply it.  The theory is
5505  * that perhaps Acer have included blocking capacitors between the ALC260
5506  * and the output jack.  If this turns out to be the case for all such
5507  * models the "Line Jack Mode" mode could be changed from ALC_PIN_DIR_INOUT
5508  * to ALC_PIN_DIR_INOUT_NOMICBIAS.
5509  *
5510  * The C20x Tablet series have a mono internal speaker which is controlled
5511  * via the chip's Mono sum widget and pin complex, so include the necessary
5512  * controls for such models.  On models without a "mono speaker" the control
5513  * won't do anything.
5514  */
5515 static struct snd_kcontrol_new alc260_acer_mixer[] = {
5516         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5517         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5518         ALC_PIN_MODE("Headphone Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5519         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0a, 1, 0x0,
5520                               HDA_OUTPUT),
5521         HDA_BIND_MUTE_MONO("Speaker Playback Switch", 0x0a, 1, 2,
5522                            HDA_INPUT),
5523         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5524         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5525         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5526         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5527         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5528         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5529         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5530         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5531         { } /* end */
5532 };
5533
5534 /* Maxdata Favorit 100XS: one output and one input (0x12) jack
5535  */
5536 static struct snd_kcontrol_new alc260_favorit100_mixer[] = {
5537         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5538         HDA_BIND_MUTE("Master Playback Switch", 0x08, 2, HDA_INPUT),
5539         ALC_PIN_MODE("Output Jack Mode", 0x0f, ALC_PIN_DIR_INOUT),
5540         HDA_CODEC_VOLUME("Line/Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5541         HDA_CODEC_MUTE("Line/Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5542         ALC_PIN_MODE("Line/Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5543         { } /* end */
5544 };
5545
5546 /* Packard bell V7900  ALC260 pin usage: HP = 0x0f, Mic jack = 0x12,
5547  * Line In jack = 0x14, CD audio =  0x16, pc beep = 0x17.
5548  */
5549 static struct snd_kcontrol_new alc260_will_mixer[] = {
5550         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5551         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5552         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5553         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5554         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5555         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5556         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5557         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5558         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
5559         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
5560         { } /* end */
5561 };
5562
5563 /* Replacer 672V ALC260 pin usage: Mic jack = 0x12,
5564  * Line In jack = 0x14, ATAPI Mic = 0x13, speaker = 0x0f.
5565  */
5566 static struct snd_kcontrol_new alc260_replacer_672v_mixer[] = {
5567         HDA_CODEC_VOLUME("Master Playback Volume", 0x08, 0x0, HDA_OUTPUT),
5568         HDA_BIND_MUTE("Master Playback Switch", 0x08, 0x2, HDA_INPUT),
5569         HDA_CODEC_VOLUME("Mic Playback Volume", 0x07, 0x0, HDA_INPUT),
5570         HDA_CODEC_MUTE("Mic Playback Switch", 0x07, 0x0, HDA_INPUT),
5571         ALC_PIN_MODE("Mic Jack Mode", 0x12, ALC_PIN_DIR_IN),
5572         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x07, 0x1, HDA_INPUT),
5573         HDA_CODEC_MUTE("ATATI Mic Playback Switch", 0x07, 0x1, HDA_INPUT),
5574         HDA_CODEC_VOLUME("Line Playback Volume", 0x07, 0x02, HDA_INPUT),
5575         HDA_CODEC_MUTE("Line Playback Switch", 0x07, 0x02, HDA_INPUT),
5576         ALC_PIN_MODE("Line Jack Mode", 0x14, ALC_PIN_DIR_INOUT),
5577         { } /* end */
5578 };
5579
5580 /*
5581  * initialization verbs
5582  */
5583 static struct hda_verb alc260_init_verbs[] = {
5584         /* Line In pin widget for input */
5585         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5586         /* CD pin widget for input */
5587         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5588         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5589         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5590         /* Mic2 (front panel) pin widget for input and vref at 80% */
5591         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
5592         /* LINE-2 is used for line-out in rear */
5593         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5594         /* select line-out */
5595         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
5596         /* LINE-OUT pin */
5597         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5598         /* enable HP */
5599         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5600         /* enable Mono */
5601         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5602         /* mute capture amp left and right */
5603         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5604         /* set connection select to line in (default select for this ADC) */
5605         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5606         /* mute capture amp left and right */
5607         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5608         /* set connection select to line in (default select for this ADC) */
5609         {0x05, AC_VERB_SET_CONNECT_SEL, 0x02},
5610         /* set vol=0 Line-Out mixer amp left and right */
5611         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5612         /* unmute pin widget amp left and right (no gain on this amp) */
5613         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5614         /* set vol=0 HP mixer amp left and right */
5615         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5616         /* unmute pin widget amp left and right (no gain on this amp) */
5617         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5618         /* set vol=0 Mono mixer amp left and right */
5619         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5620         /* unmute pin widget amp left and right (no gain on this amp) */
5621         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5622         /* unmute LINE-2 out pin */
5623         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5624         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5625          * Line In 2 = 0x03
5626          */
5627         /* mute analog inputs */
5628         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5629         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5630         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5631         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5632         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5633         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5634         /* mute Front out path */
5635         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5636         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5637         /* mute Headphone out path */
5638         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5639         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5640         /* mute Mono out path */
5641         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5642         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5643         { }
5644 };
5645
5646 #if 0 /* should be identical with alc260_init_verbs? */
5647 static struct hda_verb alc260_hp_init_verbs[] = {
5648         /* Headphone and output */
5649         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5650         /* mono output */
5651         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5652         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5653         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5654         /* Mic2 (front panel) pin widget for input and vref at 80% */
5655         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5656         /* Line In pin widget for input */
5657         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5658         /* Line-2 pin widget for output */
5659         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5660         /* CD pin widget for input */
5661         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5662         /* unmute amp left and right */
5663         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5664         /* set connection select to line in (default select for this ADC) */
5665         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5666         /* unmute Line-Out mixer amp left and right (volume = 0) */
5667         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5668         /* mute pin widget amp left and right (no gain on this amp) */
5669         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5670         /* unmute HP mixer amp left and right (volume = 0) */
5671         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5672         /* mute pin widget amp left and right (no gain on this amp) */
5673         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5674         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5675          * Line In 2 = 0x03
5676          */
5677         /* mute analog inputs */
5678         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5679         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5680         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5681         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5682         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5683         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5684         /* Unmute Front out path */
5685         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5686         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5687         /* Unmute Headphone out path */
5688         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5689         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5690         /* Unmute Mono out path */
5691         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5692         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5693         { }
5694 };
5695 #endif
5696
5697 static struct hda_verb alc260_hp_3013_init_verbs[] = {
5698         /* Line out and output */
5699         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5700         /* mono output */
5701         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
5702         /* Mic1 (rear panel) pin widget for input and vref at 80% */
5703         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5704         /* Mic2 (front panel) pin widget for input and vref at 80% */
5705         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
5706         /* Line In pin widget for input */
5707         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5708         /* Headphone pin widget for output */
5709         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
5710         /* CD pin widget for input */
5711         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
5712         /* unmute amp left and right */
5713         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000},
5714         /* set connection select to line in (default select for this ADC) */
5715         {0x04, AC_VERB_SET_CONNECT_SEL, 0x02},
5716         /* unmute Line-Out mixer amp left and right (volume = 0) */
5717         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5718         /* mute pin widget amp left and right (no gain on this amp) */
5719         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5720         /* unmute HP mixer amp left and right (volume = 0) */
5721         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0xb000},
5722         /* mute pin widget amp left and right (no gain on this amp) */
5723         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
5724         /* Amp Indexes: CD = 0x04, Line In 1 = 0x02, Mic 1 = 0x00 &
5725          * Line In 2 = 0x03
5726          */
5727         /* mute analog inputs */
5728         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5729         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5730         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
5731         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
5732         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
5733         /* Amp Indexes: DAC = 0x01 & mixer = 0x00 */
5734         /* Unmute Front out path */
5735         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5736         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5737         /* Unmute Headphone out path */
5738         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5739         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5740         /* Unmute Mono out path */
5741         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
5742         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
5743         { }
5744 };
5745
5746 /* Initialisation sequence for ALC260 as configured in Fujitsu S702x
5747  * laptops.  ALC260 pin usage: Mic/Line jack = 0x12, HP jack = 0x14, CD
5748  * audio = 0x16, internal speaker = 0x10.
5749  */
5750 static struct hda_verb alc260_fujitsu_init_verbs[] = {
5751         /* Disable all GPIOs */
5752         {0x01, AC_VERB_SET_GPIO_MASK, 0},
5753         /* Internal speaker is connected to headphone pin */
5754         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5755         /* Headphone/Line-out jack connects to Line1 pin; make it an output */
5756         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
5757         /* Mic/Line-in jack is connected to mic1 pin, so make it an input */
5758         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5759         /* Ensure all other unused pins are disabled and muted. */
5760         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5761         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5762         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5763         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5764         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5765         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5766         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5767         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5768
5769         /* Disable digital (SPDIF) pins */
5770         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5771         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5772
5773         /* Ensure Line1 pin widget takes its input from the OUT1 sum bus
5774          * when acting as an output.
5775          */
5776         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5777
5778         /* Start with output sum widgets muted and their output gains at min */
5779         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5780         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5781         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5782         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5783         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5784         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5785         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5786         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5787         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5788
5789         /* Unmute HP pin widget amp left and right (no equiv mixer ctrl) */
5790         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5791         /* Unmute Line1 pin widget output buffer since it starts as an output.
5792          * If the pin mode is changed by the user the pin mode control will
5793          * take care of enabling the pin's input/output buffers as needed.
5794          * Therefore there's no need to enable the input buffer at this
5795          * stage.
5796          */
5797         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5798         /* Unmute input buffer of pin widget used for Line-in (no equiv
5799          * mixer ctrl)
5800          */
5801         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5802
5803         /* Mute capture amp left and right */
5804         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5805         /* Set ADC connection select to match default mixer setting - line
5806          * in (on mic1 pin)
5807          */
5808         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5809
5810         /* Do the same for the second ADC: mute capture input amp and
5811          * set ADC connection to line in (on mic1 pin)
5812          */
5813         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5814         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5815
5816         /* Mute all inputs to mixer widget (even unconnected ones) */
5817         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5818         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5819         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5820         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5821         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5822         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5823         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5824         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5825
5826         { }
5827 };
5828
5829 /* Initialisation sequence for ALC260 as configured in Acer TravelMate and
5830  * similar laptops (adapted from Fujitsu init verbs).
5831  */
5832 static struct hda_verb alc260_acer_init_verbs[] = {
5833         /* On TravelMate laptops, GPIO 0 enables the internal speaker and
5834          * the headphone jack.  Turn this on and rely on the standard mute
5835          * methods whenever the user wants to turn these outputs off.
5836          */
5837         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5838         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5839         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5840         /* Internal speaker/Headphone jack is connected to Line-out pin */
5841         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5842         /* Internal microphone/Mic jack is connected to Mic1 pin */
5843         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5844         /* Line In jack is connected to Line1 pin */
5845         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
5846         /* Some Acers (eg: C20x Tablets) use Mono pin for internal speaker */
5847         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
5848         /* Ensure all other unused pins are disabled and muted. */
5849         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5850         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5851         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5852         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5853         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5854         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5855         /* Disable digital (SPDIF) pins */
5856         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5857         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5858
5859         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5860          * bus when acting as outputs.
5861          */
5862         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5863         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5864
5865         /* Start with output sum widgets muted and their output gains at min */
5866         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5867         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5868         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5869         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5870         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5871         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5872         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5873         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5874         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5875
5876         /* Unmute Line-out pin widget amp left and right
5877          * (no equiv mixer ctrl)
5878          */
5879         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5880         /* Unmute mono pin widget amp output (no equiv mixer ctrl) */
5881         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5882         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5883          * inputs. If the pin mode is changed by the user the pin mode control
5884          * will take care of enabling the pin's input/output buffers as needed.
5885          * Therefore there's no need to enable the input buffer at this
5886          * stage.
5887          */
5888         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5889         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5890
5891         /* Mute capture amp left and right */
5892         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5893         /* Set ADC connection select to match default mixer setting - mic
5894          * (on mic1 pin)
5895          */
5896         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5897
5898         /* Do similar with the second ADC: mute capture input amp and
5899          * set ADC connection to mic to match ALSA's default state.
5900          */
5901         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5902         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5903
5904         /* Mute all inputs to mixer widget (even unconnected ones) */
5905         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5906         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5907         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5908         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5909         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5910         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5911         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5912         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5913
5914         { }
5915 };
5916
5917 /* Initialisation sequence for Maxdata Favorit 100XS
5918  * (adapted from Acer init verbs).
5919  */
5920 static struct hda_verb alc260_favorit100_init_verbs[] = {
5921         /* GPIO 0 enables the output jack.
5922          * Turn this on and rely on the standard mute
5923          * methods whenever the user wants to turn these outputs off.
5924          */
5925         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
5926         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
5927         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
5928         /* Line/Mic input jack is connected to Mic1 pin */
5929         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
5930         /* Ensure all other unused pins are disabled and muted. */
5931         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5932         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5933         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5934         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5935         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5936         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5937         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5938         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5939         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0},
5940         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5941         /* Disable digital (SPDIF) pins */
5942         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
5943         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
5944
5945         /* Ensure Mic1 and Line1 pin widgets take input from the OUT1 sum
5946          * bus when acting as outputs.
5947          */
5948         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
5949         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
5950
5951         /* Start with output sum widgets muted and their output gains at min */
5952         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5953         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5954         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5955         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5956         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5957         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5958         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5959         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
5960         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
5961
5962         /* Unmute Line-out pin widget amp left and right
5963          * (no equiv mixer ctrl)
5964          */
5965         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
5966         /* Unmute Mic1 and Line1 pin widget input buffers since they start as
5967          * inputs. If the pin mode is changed by the user the pin mode control
5968          * will take care of enabling the pin's input/output buffers as needed.
5969          * Therefore there's no need to enable the input buffer at this
5970          * stage.
5971          */
5972         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
5973
5974         /* Mute capture amp left and right */
5975         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5976         /* Set ADC connection select to match default mixer setting - mic
5977          * (on mic1 pin)
5978          */
5979         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
5980
5981         /* Do similar with the second ADC: mute capture input amp and
5982          * set ADC connection to mic to match ALSA's default state.
5983          */
5984         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
5985         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
5986
5987         /* Mute all inputs to mixer widget (even unconnected ones) */
5988         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
5989         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
5990         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
5991         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
5992         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
5993         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
5994         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
5995         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
5996
5997         { }
5998 };
5999
6000 static struct hda_verb alc260_will_verbs[] = {
6001         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6002         {0x0b, AC_VERB_SET_CONNECT_SEL, 0x00},
6003         {0x0d, AC_VERB_SET_CONNECT_SEL, 0x00},
6004         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6005         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6006         {0x1a, AC_VERB_SET_PROC_COEF, 0x3040},
6007         {}
6008 };
6009
6010 static struct hda_verb alc260_replacer_672v_verbs[] = {
6011         {0x0f, AC_VERB_SET_EAPD_BTLENABLE, 0x02},
6012         {0x1a, AC_VERB_SET_COEF_INDEX, 0x07},
6013         {0x1a, AC_VERB_SET_PROC_COEF, 0x3050},
6014
6015         {0x01, AC_VERB_SET_GPIO_MASK, 0x01},
6016         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
6017         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6018
6019         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6020         {}
6021 };
6022
6023 /* toggle speaker-output according to the hp-jack state */
6024 static void alc260_replacer_672v_automute(struct hda_codec *codec)
6025 {
6026         unsigned int present;
6027
6028         /* speaker --> GPIO Data 0, hp or spdif --> GPIO data 1 */
6029         present = snd_hda_jack_detect(codec, 0x0f);
6030         if (present) {
6031                 snd_hda_codec_write_cache(codec, 0x01, 0,
6032                                           AC_VERB_SET_GPIO_DATA, 1);
6033                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6034                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6035                                           PIN_HP);
6036         } else {
6037                 snd_hda_codec_write_cache(codec, 0x01, 0,
6038                                           AC_VERB_SET_GPIO_DATA, 0);
6039                 snd_hda_codec_write_cache(codec, 0x0f, 0,
6040                                           AC_VERB_SET_PIN_WIDGET_CONTROL,
6041                                           PIN_OUT);
6042         }
6043 }
6044
6045 static void alc260_replacer_672v_unsol_event(struct hda_codec *codec,
6046                                        unsigned int res)
6047 {
6048         if ((res >> 26) == ALC880_HP_EVENT)
6049                 alc260_replacer_672v_automute(codec);
6050 }
6051
6052 static struct hda_verb alc260_hp_dc7600_verbs[] = {
6053         {0x05, AC_VERB_SET_CONNECT_SEL, 0x01},
6054         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
6055         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6056         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
6057         {0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6058         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6059         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
6060         {0x10, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6061         {0x11, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6062         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
6063         {}
6064 };
6065
6066 /* Test configuration for debugging, modelled after the ALC880 test
6067  * configuration.
6068  */
6069 #ifdef CONFIG_SND_DEBUG
6070 static hda_nid_t alc260_test_dac_nids[1] = {
6071         0x02,
6072 };
6073 static hda_nid_t alc260_test_adc_nids[2] = {
6074         0x04, 0x05,
6075 };
6076 /* For testing the ALC260, each input MUX needs its own definition since
6077  * the signal assignments are different.  This assumes that the first ADC
6078  * is NID 0x04.
6079  */
6080 static struct hda_input_mux alc260_test_capture_sources[2] = {
6081         {
6082                 .num_items = 7,
6083                 .items = {
6084                         { "MIC1 pin", 0x0 },
6085                         { "MIC2 pin", 0x1 },
6086                         { "LINE1 pin", 0x2 },
6087                         { "LINE2 pin", 0x3 },
6088                         { "CD pin", 0x4 },
6089                         { "LINE-OUT pin", 0x5 },
6090                         { "HP-OUT pin", 0x6 },
6091                 },
6092         },
6093         {
6094                 .num_items = 8,
6095                 .items = {
6096                         { "MIC1 pin", 0x0 },
6097                         { "MIC2 pin", 0x1 },
6098                         { "LINE1 pin", 0x2 },
6099                         { "LINE2 pin", 0x3 },
6100                         { "CD pin", 0x4 },
6101                         { "Mixer", 0x5 },
6102                         { "LINE-OUT pin", 0x6 },
6103                         { "HP-OUT pin", 0x7 },
6104                 },
6105         },
6106 };
6107 static struct snd_kcontrol_new alc260_test_mixer[] = {
6108         /* Output driver widgets */
6109         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0a, 1, 0x0, HDA_OUTPUT),
6110         HDA_BIND_MUTE_MONO("Mono Playback Switch", 0x0a, 1, 2, HDA_INPUT),
6111         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x09, 0x0, HDA_OUTPUT),
6112         HDA_BIND_MUTE("LOUT2 Playback Switch", 0x09, 2, HDA_INPUT),
6113         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x08, 0x0, HDA_OUTPUT),
6114         HDA_BIND_MUTE("LOUT1 Playback Switch", 0x08, 2, HDA_INPUT),
6115
6116         /* Modes for retasking pin widgets
6117          * Note: the ALC260 doesn't seem to act on requests to enable mic
6118          * bias from NIDs 0x0f and 0x10.  The ALC260 datasheet doesn't
6119          * mention this restriction.  At this stage it's not clear whether
6120          * this behaviour is intentional or is a hardware bug in chip
6121          * revisions available at least up until early 2006.  Therefore for
6122          * now allow the "HP-OUT" and "LINE-OUT" Mode controls to span all
6123          * choices, but if it turns out that the lack of mic bias for these
6124          * NIDs is intentional we could change their modes from
6125          * ALC_PIN_DIR_INOUT to ALC_PIN_DIR_INOUT_NOMICBIAS.
6126          */
6127         ALC_PIN_MODE("HP-OUT pin mode", 0x10, ALC_PIN_DIR_INOUT),
6128         ALC_PIN_MODE("LINE-OUT pin mode", 0x0f, ALC_PIN_DIR_INOUT),
6129         ALC_PIN_MODE("LINE2 pin mode", 0x15, ALC_PIN_DIR_INOUT),
6130         ALC_PIN_MODE("LINE1 pin mode", 0x14, ALC_PIN_DIR_INOUT),
6131         ALC_PIN_MODE("MIC2 pin mode", 0x13, ALC_PIN_DIR_INOUT),
6132         ALC_PIN_MODE("MIC1 pin mode", 0x12, ALC_PIN_DIR_INOUT),
6133
6134         /* Loopback mixer controls */
6135         HDA_CODEC_VOLUME("MIC1 Playback Volume", 0x07, 0x00, HDA_INPUT),
6136         HDA_CODEC_MUTE("MIC1 Playback Switch", 0x07, 0x00, HDA_INPUT),
6137         HDA_CODEC_VOLUME("MIC2 Playback Volume", 0x07, 0x01, HDA_INPUT),
6138         HDA_CODEC_MUTE("MIC2 Playback Switch", 0x07, 0x01, HDA_INPUT),
6139         HDA_CODEC_VOLUME("LINE1 Playback Volume", 0x07, 0x02, HDA_INPUT),
6140         HDA_CODEC_MUTE("LINE1 Playback Switch", 0x07, 0x02, HDA_INPUT),
6141         HDA_CODEC_VOLUME("LINE2 Playback Volume", 0x07, 0x03, HDA_INPUT),
6142         HDA_CODEC_MUTE("LINE2 Playback Switch", 0x07, 0x03, HDA_INPUT),
6143         HDA_CODEC_VOLUME("CD Playback Volume", 0x07, 0x04, HDA_INPUT),
6144         HDA_CODEC_MUTE("CD Playback Switch", 0x07, 0x04, HDA_INPUT),
6145         HDA_CODEC_VOLUME("LINE-OUT loopback Playback Volume", 0x07, 0x06, HDA_INPUT),
6146         HDA_CODEC_MUTE("LINE-OUT loopback Playback Switch", 0x07, 0x06, HDA_INPUT),
6147         HDA_CODEC_VOLUME("HP-OUT loopback Playback Volume", 0x07, 0x7, HDA_INPUT),
6148         HDA_CODEC_MUTE("HP-OUT loopback Playback Switch", 0x07, 0x7, HDA_INPUT),
6149
6150         /* Controls for GPIO pins, assuming they are configured as outputs */
6151         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
6152         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
6153         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
6154         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
6155
6156         /* Switches to allow the digital IO pins to be enabled.  The datasheet
6157          * is ambigious as to which NID is which; testing on laptops which
6158          * make this output available should provide clarification.
6159          */
6160         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x03, 0x01),
6161         ALC_SPDIF_CTRL_SWITCH("SPDIF Capture Switch", 0x06, 0x01),
6162
6163         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
6164          * this output to turn on an external amplifier.
6165          */
6166         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
6167         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
6168
6169         { } /* end */
6170 };
6171 static struct hda_verb alc260_test_init_verbs[] = {
6172         /* Enable all GPIOs as outputs with an initial value of 0 */
6173         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x0f},
6174         {0x01, AC_VERB_SET_GPIO_DATA, 0x00},
6175         {0x01, AC_VERB_SET_GPIO_MASK, 0x0f},
6176
6177         /* Enable retasking pins as output, initially without power amp */
6178         {0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6179         {0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6180         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6181         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6182         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6183         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
6184
6185         /* Disable digital (SPDIF) pins initially, but users can enable
6186          * them via a mixer switch.  In the case of SPDIF-out, this initverb
6187          * payload also sets the generation to 0, output to be in "consumer"
6188          * PCM format, copyright asserted, no pre-emphasis and no validity
6189          * control.
6190          */
6191         {0x03, AC_VERB_SET_DIGI_CONVERT_1, 0},
6192         {0x06, AC_VERB_SET_DIGI_CONVERT_1, 0},
6193
6194         /* Ensure mic1, mic2, line1 and line2 pin widgets take input from the
6195          * OUT1 sum bus when acting as an output.
6196          */
6197         {0x0b, AC_VERB_SET_CONNECT_SEL, 0},
6198         {0x0c, AC_VERB_SET_CONNECT_SEL, 0},
6199         {0x0d, AC_VERB_SET_CONNECT_SEL, 0},
6200         {0x0e, AC_VERB_SET_CONNECT_SEL, 0},
6201
6202         /* Start with output sum widgets muted and their output gains at min */
6203         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6204         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6205         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6206         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6207         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6208         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6209         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6210         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6211         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6212
6213         /* Unmute retasking pin widget output buffers since the default
6214          * state appears to be output.  As the pin mode is changed by the
6215          * user the pin mode control will take care of enabling the pin's
6216          * input/output buffers as needed.
6217          */
6218         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6219         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6220         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6221         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6222         {0x13, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6223         {0x12, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6224         /* Also unmute the mono-out pin widget */
6225         {0x11, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
6226
6227         /* Mute capture amp left and right */
6228         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6229         /* Set ADC connection select to match default mixer setting (mic1
6230          * pin)
6231          */
6232         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6233
6234         /* Do the same for the second ADC: mute capture input amp and
6235          * set ADC connection to mic1 pin
6236          */
6237         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6238         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6239
6240         /* Mute all inputs to mixer widget (even unconnected ones) */
6241         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)}, /* mic1 pin */
6242         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)}, /* mic2 pin */
6243         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)}, /* line1 pin */
6244         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)}, /* line2 pin */
6245         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)}, /* CD pin */
6246         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)}, /* Beep-gen pin */
6247         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)}, /* Line-out pin */
6248         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)}, /* HP-pin pin */
6249
6250         { }
6251 };
6252 #endif
6253
6254 #define alc260_pcm_analog_playback      alc880_pcm_analog_alt_playback
6255 #define alc260_pcm_analog_capture       alc880_pcm_analog_capture
6256
6257 #define alc260_pcm_digital_playback     alc880_pcm_digital_playback
6258 #define alc260_pcm_digital_capture      alc880_pcm_digital_capture
6259
6260 /*
6261  * for BIOS auto-configuration
6262  */
6263
6264 static int alc260_add_playback_controls(struct alc_spec *spec, hda_nid_t nid,
6265                                         const char *pfx, int *vol_bits)
6266 {
6267         hda_nid_t nid_vol;
6268         unsigned long vol_val, sw_val;
6269         int err;
6270
6271         if (nid >= 0x0f && nid < 0x11) {
6272                 nid_vol = nid - 0x7;
6273                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6274                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6275         } else if (nid == 0x11) {
6276                 nid_vol = nid - 0x7;
6277                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 2, 0, HDA_OUTPUT);
6278                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
6279         } else if (nid >= 0x12 && nid <= 0x15) {
6280                 nid_vol = 0x08;
6281                 vol_val = HDA_COMPOSE_AMP_VAL(nid_vol, 3, 0, HDA_OUTPUT);
6282                 sw_val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
6283         } else
6284                 return 0; /* N/A */
6285
6286         if (!(*vol_bits & (1 << nid_vol))) {
6287                 /* first control for the volume widget */
6288                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, vol_val);
6289                 if (err < 0)
6290                         return err;
6291                 *vol_bits |= (1 << nid_vol);
6292         }
6293         err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, sw_val);
6294         if (err < 0)
6295                 return err;
6296         return 1;
6297 }
6298
6299 /* add playback controls from the parsed DAC table */
6300 static int alc260_auto_create_multi_out_ctls(struct alc_spec *spec,
6301                                              const struct auto_pin_cfg *cfg)
6302 {
6303         hda_nid_t nid;
6304         int err;
6305         int vols = 0;
6306
6307         spec->multiout.num_dacs = 1;
6308         spec->multiout.dac_nids = spec->private_dac_nids;
6309         spec->multiout.dac_nids[0] = 0x02;
6310
6311         nid = cfg->line_out_pins[0];
6312         if (nid) {
6313                 const char *pfx;
6314                 if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
6315                         pfx = "Master";
6316                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
6317                         pfx = "Speaker";
6318                 else
6319                         pfx = "Front";
6320                 err = alc260_add_playback_controls(spec, nid, pfx, &vols);
6321                 if (err < 0)
6322                         return err;
6323         }
6324
6325         nid = cfg->speaker_pins[0];
6326         if (nid) {
6327                 err = alc260_add_playback_controls(spec, nid, "Speaker", &vols);
6328                 if (err < 0)
6329                         return err;
6330         }
6331
6332         nid = cfg->hp_pins[0];
6333         if (nid) {
6334                 err = alc260_add_playback_controls(spec, nid, "Headphone",
6335                                                    &vols);
6336                 if (err < 0)
6337                         return err;
6338         }
6339         return 0;
6340 }
6341
6342 /* create playback/capture controls for input pins */
6343 static int alc260_auto_create_input_ctls(struct hda_codec *codec,
6344                                                 const struct auto_pin_cfg *cfg)
6345 {
6346         return alc_auto_create_input_ctls(codec, cfg, 0x07, 0x04, 0x05);
6347 }
6348
6349 static void alc260_auto_set_output_and_unmute(struct hda_codec *codec,
6350                                               hda_nid_t nid, int pin_type,
6351                                               int sel_idx)
6352 {
6353         alc_set_pin_output(codec, nid, pin_type);
6354         /* need the manual connection? */
6355         if (nid >= 0x12) {
6356                 int idx = nid - 0x12;
6357                 snd_hda_codec_write(codec, idx + 0x0b, 0,
6358                                     AC_VERB_SET_CONNECT_SEL, sel_idx);
6359         }
6360 }
6361
6362 static void alc260_auto_init_multi_out(struct hda_codec *codec)
6363 {
6364         struct alc_spec *spec = codec->spec;
6365         hda_nid_t nid;
6366
6367         nid = spec->autocfg.line_out_pins[0];
6368         if (nid) {
6369                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
6370                 alc260_auto_set_output_and_unmute(codec, nid, pin_type, 0);
6371         }
6372
6373         nid = spec->autocfg.speaker_pins[0];
6374         if (nid)
6375                 alc260_auto_set_output_and_unmute(codec, nid, PIN_OUT, 0);
6376
6377         nid = spec->autocfg.hp_pins[0];
6378         if (nid)
6379                 alc260_auto_set_output_and_unmute(codec, nid, PIN_HP, 0);
6380 }
6381
6382 #define ALC260_PIN_CD_NID               0x16
6383 static void alc260_auto_init_analog_input(struct hda_codec *codec)
6384 {
6385         struct alc_spec *spec = codec->spec;
6386         int i;
6387
6388         for (i = 0; i < AUTO_PIN_LAST; i++) {
6389                 hda_nid_t nid = spec->autocfg.input_pins[i];
6390                 if (nid >= 0x12) {
6391                         alc_set_input_pin(codec, nid, i);
6392                         if (nid != ALC260_PIN_CD_NID &&
6393                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
6394                                 snd_hda_codec_write(codec, nid, 0,
6395                                                     AC_VERB_SET_AMP_GAIN_MUTE,
6396                                                     AMP_OUT_MUTE);
6397                 }
6398         }
6399 }
6400
6401 /*
6402  * generic initialization of ADC, input mixers and output mixers
6403  */
6404 static struct hda_verb alc260_volume_init_verbs[] = {
6405         /*
6406          * Unmute ADC0-1 and set the default input to mic-in
6407          */
6408         {0x04, AC_VERB_SET_CONNECT_SEL, 0x00},
6409         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6410         {0x05, AC_VERB_SET_CONNECT_SEL, 0x00},
6411         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6412
6413         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
6414          * mixer widget
6415          * Note: PASD motherboards uses the Line In 2 as the input for
6416          * front panel mic (mic 2)
6417          */
6418         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
6419         /* mute analog inputs */
6420         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
6421         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
6422         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
6423         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
6424         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
6425
6426         /*
6427          * Set up output mixers (0x08 - 0x0a)
6428          */
6429         /* set vol=0 to output mixers */
6430         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6431         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6432         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
6433         /* set up input amps for analog loopback */
6434         /* Amp Indices: DAC = 0, mixer = 1 */
6435         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6436         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6437         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6438         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6439         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
6440         {0x0a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
6441
6442         { }
6443 };
6444
6445 static int alc260_parse_auto_config(struct hda_codec *codec)
6446 {
6447         struct alc_spec *spec = codec->spec;
6448         int err;
6449         static hda_nid_t alc260_ignore[] = { 0x17, 0 };
6450
6451         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
6452                                            alc260_ignore);
6453         if (err < 0)
6454                 return err;
6455         err = alc260_auto_create_multi_out_ctls(spec, &spec->autocfg);
6456         if (err < 0)
6457                 return err;
6458         if (!spec->kctls.list)
6459                 return 0; /* can't find valid BIOS pin config */
6460         err = alc260_auto_create_input_ctls(codec, &spec->autocfg);
6461         if (err < 0)
6462                 return err;
6463
6464         spec->multiout.max_channels = 2;
6465
6466         if (spec->autocfg.dig_outs)
6467                 spec->multiout.dig_out_nid = ALC260_DIGOUT_NID;
6468         if (spec->kctls.list)
6469                 add_mixer(spec, spec->kctls.list);
6470
6471         add_verb(spec, alc260_volume_init_verbs);
6472
6473         spec->num_mux_defs = 1;
6474         spec->input_mux = &spec->private_imux[0];
6475
6476         alc_ssid_check(codec, 0x10, 0x15, 0x0f, 0);
6477
6478         return 1;
6479 }
6480
6481 /* additional initialization for auto-configuration model */
6482 static void alc260_auto_init(struct hda_codec *codec)
6483 {
6484         struct alc_spec *spec = codec->spec;
6485         alc260_auto_init_multi_out(codec);
6486         alc260_auto_init_analog_input(codec);
6487         if (spec->unsol_event)
6488                 alc_inithook(codec);
6489 }
6490
6491 #ifdef CONFIG_SND_HDA_POWER_SAVE
6492 static struct hda_amp_list alc260_loopbacks[] = {
6493         { 0x07, HDA_INPUT, 0 },
6494         { 0x07, HDA_INPUT, 1 },
6495         { 0x07, HDA_INPUT, 2 },
6496         { 0x07, HDA_INPUT, 3 },
6497         { 0x07, HDA_INPUT, 4 },
6498         { } /* end */
6499 };
6500 #endif
6501
6502 /*
6503  * ALC260 configurations
6504  */
6505 static const char *alc260_models[ALC260_MODEL_LAST] = {
6506         [ALC260_BASIC]          = "basic",
6507         [ALC260_HP]             = "hp",
6508         [ALC260_HP_3013]        = "hp-3013",
6509         [ALC260_HP_DC7600]      = "hp-dc7600",
6510         [ALC260_FUJITSU_S702X]  = "fujitsu",
6511         [ALC260_ACER]           = "acer",
6512         [ALC260_WILL]           = "will",
6513         [ALC260_REPLACER_672V]  = "replacer",
6514         [ALC260_FAVORIT100]     = "favorit100",
6515 #ifdef CONFIG_SND_DEBUG
6516         [ALC260_TEST]           = "test",
6517 #endif
6518         [ALC260_AUTO]           = "auto",
6519 };
6520
6521 static struct snd_pci_quirk alc260_cfg_tbl[] = {
6522         SND_PCI_QUIRK(0x1025, 0x007b, "Acer C20x", ALC260_ACER),
6523         SND_PCI_QUIRK(0x1025, 0x007f, "Acer", ALC260_WILL),
6524         SND_PCI_QUIRK(0x1025, 0x008f, "Acer", ALC260_ACER),
6525         SND_PCI_QUIRK(0x1509, 0x4540, "Favorit 100XS", ALC260_FAVORIT100),
6526         SND_PCI_QUIRK(0x103c, 0x2808, "HP d5700", ALC260_HP_3013),
6527         SND_PCI_QUIRK(0x103c, 0x280a, "HP d5750", ALC260_AUTO), /* no quirk */
6528         SND_PCI_QUIRK(0x103c, 0x3010, "HP", ALC260_HP_3013),
6529         SND_PCI_QUIRK(0x103c, 0x3011, "HP", ALC260_HP_3013),
6530         SND_PCI_QUIRK(0x103c, 0x3012, "HP", ALC260_HP_DC7600),
6531         SND_PCI_QUIRK(0x103c, 0x3013, "HP", ALC260_HP_3013),
6532         SND_PCI_QUIRK(0x103c, 0x3014, "HP", ALC260_HP),
6533         SND_PCI_QUIRK(0x103c, 0x3015, "HP", ALC260_HP),
6534         SND_PCI_QUIRK(0x103c, 0x3016, "HP", ALC260_HP),
6535         SND_PCI_QUIRK(0x104d, 0x81bb, "Sony VAIO", ALC260_BASIC),
6536         SND_PCI_QUIRK(0x104d, 0x81cc, "Sony VAIO", ALC260_BASIC),
6537         SND_PCI_QUIRK(0x104d, 0x81cd, "Sony VAIO", ALC260_BASIC),
6538         SND_PCI_QUIRK(0x10cf, 0x1326, "Fujitsu S702X", ALC260_FUJITSU_S702X),
6539         SND_PCI_QUIRK(0x152d, 0x0729, "CTL U553W", ALC260_BASIC),
6540         SND_PCI_QUIRK(0x161f, 0x2057, "Replacer 672V", ALC260_REPLACER_672V),
6541         SND_PCI_QUIRK(0x1631, 0xc017, "PB V7900", ALC260_WILL),
6542         {}
6543 };
6544
6545 static struct alc_config_preset alc260_presets[] = {
6546         [ALC260_BASIC] = {
6547                 .mixers = { alc260_base_output_mixer,
6548                             alc260_input_mixer },
6549                 .init_verbs = { alc260_init_verbs },
6550                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6551                 .dac_nids = alc260_dac_nids,
6552                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6553                 .adc_nids = alc260_dual_adc_nids,
6554                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6555                 .channel_mode = alc260_modes,
6556                 .input_mux = &alc260_capture_source,
6557         },
6558         [ALC260_HP] = {
6559                 .mixers = { alc260_hp_output_mixer,
6560                             alc260_input_mixer },
6561                 .init_verbs = { alc260_init_verbs,
6562                                 alc260_hp_unsol_verbs },
6563                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6564                 .dac_nids = alc260_dac_nids,
6565                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6566                 .adc_nids = alc260_adc_nids_alt,
6567                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6568                 .channel_mode = alc260_modes,
6569                 .input_mux = &alc260_capture_source,
6570                 .unsol_event = alc260_hp_unsol_event,
6571                 .init_hook = alc260_hp_automute,
6572         },
6573         [ALC260_HP_DC7600] = {
6574                 .mixers = { alc260_hp_dc7600_mixer,
6575                             alc260_input_mixer },
6576                 .init_verbs = { alc260_init_verbs,
6577                                 alc260_hp_dc7600_verbs },
6578                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6579                 .dac_nids = alc260_dac_nids,
6580                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6581                 .adc_nids = alc260_adc_nids_alt,
6582                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6583                 .channel_mode = alc260_modes,
6584                 .input_mux = &alc260_capture_source,
6585                 .unsol_event = alc260_hp_3012_unsol_event,
6586                 .init_hook = alc260_hp_3012_automute,
6587         },
6588         [ALC260_HP_3013] = {
6589                 .mixers = { alc260_hp_3013_mixer,
6590                             alc260_input_mixer },
6591                 .init_verbs = { alc260_hp_3013_init_verbs,
6592                                 alc260_hp_3013_unsol_verbs },
6593                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6594                 .dac_nids = alc260_dac_nids,
6595                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt),
6596                 .adc_nids = alc260_adc_nids_alt,
6597                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6598                 .channel_mode = alc260_modes,
6599                 .input_mux = &alc260_capture_source,
6600                 .unsol_event = alc260_hp_3013_unsol_event,
6601                 .init_hook = alc260_hp_3013_automute,
6602         },
6603         [ALC260_FUJITSU_S702X] = {
6604                 .mixers = { alc260_fujitsu_mixer },
6605                 .init_verbs = { alc260_fujitsu_init_verbs },
6606                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6607                 .dac_nids = alc260_dac_nids,
6608                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6609                 .adc_nids = alc260_dual_adc_nids,
6610                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6611                 .channel_mode = alc260_modes,
6612                 .num_mux_defs = ARRAY_SIZE(alc260_fujitsu_capture_sources),
6613                 .input_mux = alc260_fujitsu_capture_sources,
6614         },
6615         [ALC260_ACER] = {
6616                 .mixers = { alc260_acer_mixer },
6617                 .init_verbs = { alc260_acer_init_verbs },
6618                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6619                 .dac_nids = alc260_dac_nids,
6620                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6621                 .adc_nids = alc260_dual_adc_nids,
6622                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6623                 .channel_mode = alc260_modes,
6624                 .num_mux_defs = ARRAY_SIZE(alc260_acer_capture_sources),
6625                 .input_mux = alc260_acer_capture_sources,
6626         },
6627         [ALC260_FAVORIT100] = {
6628                 .mixers = { alc260_favorit100_mixer },
6629                 .init_verbs = { alc260_favorit100_init_verbs },
6630                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6631                 .dac_nids = alc260_dac_nids,
6632                 .num_adc_nids = ARRAY_SIZE(alc260_dual_adc_nids),
6633                 .adc_nids = alc260_dual_adc_nids,
6634                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6635                 .channel_mode = alc260_modes,
6636                 .num_mux_defs = ARRAY_SIZE(alc260_favorit100_capture_sources),
6637                 .input_mux = alc260_favorit100_capture_sources,
6638         },
6639         [ALC260_WILL] = {
6640                 .mixers = { alc260_will_mixer },
6641                 .init_verbs = { alc260_init_verbs, alc260_will_verbs },
6642                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6643                 .dac_nids = alc260_dac_nids,
6644                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6645                 .adc_nids = alc260_adc_nids,
6646                 .dig_out_nid = ALC260_DIGOUT_NID,
6647                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6648                 .channel_mode = alc260_modes,
6649                 .input_mux = &alc260_capture_source,
6650         },
6651         [ALC260_REPLACER_672V] = {
6652                 .mixers = { alc260_replacer_672v_mixer },
6653                 .init_verbs = { alc260_init_verbs, alc260_replacer_672v_verbs },
6654                 .num_dacs = ARRAY_SIZE(alc260_dac_nids),
6655                 .dac_nids = alc260_dac_nids,
6656                 .num_adc_nids = ARRAY_SIZE(alc260_adc_nids),
6657                 .adc_nids = alc260_adc_nids,
6658                 .dig_out_nid = ALC260_DIGOUT_NID,
6659                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6660                 .channel_mode = alc260_modes,
6661                 .input_mux = &alc260_capture_source,
6662                 .unsol_event = alc260_replacer_672v_unsol_event,
6663                 .init_hook = alc260_replacer_672v_automute,
6664         },
6665 #ifdef CONFIG_SND_DEBUG
6666         [ALC260_TEST] = {
6667                 .mixers = { alc260_test_mixer },
6668                 .init_verbs = { alc260_test_init_verbs },
6669                 .num_dacs = ARRAY_SIZE(alc260_test_dac_nids),
6670                 .dac_nids = alc260_test_dac_nids,
6671                 .num_adc_nids = ARRAY_SIZE(alc260_test_adc_nids),
6672                 .adc_nids = alc260_test_adc_nids,
6673                 .num_channel_mode = ARRAY_SIZE(alc260_modes),
6674                 .channel_mode = alc260_modes,
6675                 .num_mux_defs = ARRAY_SIZE(alc260_test_capture_sources),
6676                 .input_mux = alc260_test_capture_sources,
6677         },
6678 #endif
6679 };
6680
6681 static int patch_alc260(struct hda_codec *codec)
6682 {
6683         struct alc_spec *spec;
6684         int err, board_config;
6685
6686         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
6687         if (spec == NULL)
6688                 return -ENOMEM;
6689
6690         codec->spec = spec;
6691
6692         board_config = snd_hda_check_board_config(codec, ALC260_MODEL_LAST,
6693                                                   alc260_models,
6694                                                   alc260_cfg_tbl);
6695         if (board_config < 0) {
6696                 snd_printd(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
6697                            codec->chip_name);
6698                 board_config = ALC260_AUTO;
6699         }
6700
6701         if (board_config == ALC260_AUTO) {
6702                 /* automatic parse from the BIOS config */
6703                 err = alc260_parse_auto_config(codec);
6704                 if (err < 0) {
6705                         alc_free(codec);
6706                         return err;
6707                 } else if (!err) {
6708                         printk(KERN_INFO
6709                                "hda_codec: Cannot set up configuration "
6710                                "from BIOS.  Using base mode...\n");
6711                         board_config = ALC260_BASIC;
6712                 }
6713         }
6714
6715         err = snd_hda_attach_beep_device(codec, 0x1);
6716         if (err < 0) {
6717                 alc_free(codec);
6718                 return err;
6719         }
6720
6721         if (board_config != ALC260_AUTO)
6722                 setup_preset(codec, &alc260_presets[board_config]);
6723
6724         spec->stream_analog_playback = &alc260_pcm_analog_playback;
6725         spec->stream_analog_capture = &alc260_pcm_analog_capture;
6726
6727         spec->stream_digital_playback = &alc260_pcm_digital_playback;
6728         spec->stream_digital_capture = &alc260_pcm_digital_capture;
6729
6730         if (!spec->adc_nids && spec->input_mux) {
6731                 /* check whether NID 0x04 is valid */
6732                 unsigned int wcap = get_wcaps(codec, 0x04);
6733                 wcap = get_wcaps_type(wcap);
6734                 /* get type */
6735                 if (wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
6736                         spec->adc_nids = alc260_adc_nids_alt;
6737                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids_alt);
6738                 } else {
6739                         spec->adc_nids = alc260_adc_nids;
6740                         spec->num_adc_nids = ARRAY_SIZE(alc260_adc_nids);
6741                 }
6742         }
6743         set_capture_mixer(codec);
6744         set_beep_amp(spec, 0x07, 0x05, HDA_INPUT);
6745
6746         spec->vmaster_nid = 0x08;
6747
6748         codec->patch_ops = alc_patch_ops;
6749         if (board_config == ALC260_AUTO)
6750                 spec->init_hook = alc260_auto_init;
6751 #ifdef CONFIG_SND_HDA_POWER_SAVE
6752         if (!spec->loopback.amplist)
6753                 spec->loopback.amplist = alc260_loopbacks;
6754 #endif
6755
6756         return 0;
6757 }
6758
6759
6760 /*
6761  * ALC882/883/885/888/889 support
6762  *
6763  * ALC882 is almost identical with ALC880 but has cleaner and more flexible
6764  * configuration.  Each pin widget can choose any input DACs and a mixer.
6765  * Each ADC is connected from a mixer of all inputs.  This makes possible
6766  * 6-channel independent captures.
6767  *
6768  * In addition, an independent DAC for the multi-playback (not used in this
6769  * driver yet).
6770  */
6771 #define ALC882_DIGOUT_NID       0x06
6772 #define ALC882_DIGIN_NID        0x0a
6773 #define ALC883_DIGOUT_NID       ALC882_DIGOUT_NID
6774 #define ALC883_DIGIN_NID        ALC882_DIGIN_NID
6775 #define ALC1200_DIGOUT_NID      0x10
6776
6777
6778 static struct hda_channel_mode alc882_ch_modes[1] = {
6779         { 8, NULL }
6780 };
6781
6782 /* DACs */
6783 static hda_nid_t alc882_dac_nids[4] = {
6784         /* front, rear, clfe, rear_surr */
6785         0x02, 0x03, 0x04, 0x05
6786 };
6787 #define alc883_dac_nids         alc882_dac_nids
6788
6789 /* ADCs */
6790 #define alc882_adc_nids         alc880_adc_nids
6791 #define alc882_adc_nids_alt     alc880_adc_nids_alt
6792 #define alc883_adc_nids         alc882_adc_nids_alt
6793 static hda_nid_t alc883_adc_nids_alt[1] = { 0x08 };
6794 static hda_nid_t alc883_adc_nids_rev[2] = { 0x09, 0x08 };
6795 #define alc889_adc_nids         alc880_adc_nids
6796
6797 static hda_nid_t alc882_capsrc_nids[3] = { 0x24, 0x23, 0x22 };
6798 static hda_nid_t alc882_capsrc_nids_alt[2] = { 0x23, 0x22 };
6799 #define alc883_capsrc_nids      alc882_capsrc_nids_alt
6800 static hda_nid_t alc883_capsrc_nids_rev[2] = { 0x22, 0x23 };
6801 #define alc889_capsrc_nids      alc882_capsrc_nids
6802
6803 /* input MUX */
6804 /* FIXME: should be a matrix-type input source selection */
6805
6806 static struct hda_input_mux alc882_capture_source = {
6807         .num_items = 4,
6808         .items = {
6809                 { "Mic", 0x0 },
6810                 { "Front Mic", 0x1 },
6811                 { "Line", 0x2 },
6812                 { "CD", 0x4 },
6813         },
6814 };
6815
6816 #define alc883_capture_source   alc882_capture_source
6817
6818 static struct hda_input_mux alc889_capture_source = {
6819         .num_items = 3,
6820         .items = {
6821                 { "Front Mic", 0x0 },
6822                 { "Mic", 0x3 },
6823                 { "Line", 0x2 },
6824         },
6825 };
6826
6827 static struct hda_input_mux mb5_capture_source = {
6828         .num_items = 3,
6829         .items = {
6830                 { "Mic", 0x1 },
6831                 { "Line", 0x2 },
6832                 { "CD", 0x4 },
6833         },
6834 };
6835
6836 static struct hda_input_mux macmini3_capture_source = {
6837         .num_items = 2,
6838         .items = {
6839                 { "Line", 0x2 },
6840                 { "CD", 0x4 },
6841         },
6842 };
6843
6844 static struct hda_input_mux alc883_3stack_6ch_intel = {
6845         .num_items = 4,
6846         .items = {
6847                 { "Mic", 0x1 },
6848                 { "Front Mic", 0x0 },
6849                 { "Line", 0x2 },
6850                 { "CD", 0x4 },
6851         },
6852 };
6853
6854 static struct hda_input_mux alc883_lenovo_101e_capture_source = {
6855         .num_items = 2,
6856         .items = {
6857                 { "Mic", 0x1 },
6858                 { "Line", 0x2 },
6859         },
6860 };
6861
6862 static struct hda_input_mux alc883_lenovo_nb0763_capture_source = {
6863         .num_items = 4,
6864         .items = {
6865                 { "Mic", 0x0 },
6866                 { "iMic", 0x1 },
6867                 { "Line", 0x2 },
6868                 { "CD", 0x4 },
6869         },
6870 };
6871
6872 static struct hda_input_mux alc883_fujitsu_pi2515_capture_source = {
6873         .num_items = 2,
6874         .items = {
6875                 { "Mic", 0x0 },
6876                 { "Int Mic", 0x1 },
6877         },
6878 };
6879
6880 static struct hda_input_mux alc883_lenovo_sky_capture_source = {
6881         .num_items = 3,
6882         .items = {
6883                 { "Mic", 0x0 },
6884                 { "Front Mic", 0x1 },
6885                 { "Line", 0x4 },
6886         },
6887 };
6888
6889 static struct hda_input_mux alc883_asus_eee1601_capture_source = {
6890         .num_items = 2,
6891         .items = {
6892                 { "Mic", 0x0 },
6893                 { "Line", 0x2 },
6894         },
6895 };
6896
6897 static struct hda_input_mux alc889A_mb31_capture_source = {
6898         .num_items = 2,
6899         .items = {
6900                 { "Mic", 0x0 },
6901                 /* Front Mic (0x01) unused */
6902                 { "Line", 0x2 },
6903                 /* Line 2 (0x03) unused */
6904                 /* CD (0x04) unused? */
6905         },
6906 };
6907
6908 /*
6909  * 2ch mode
6910  */
6911 static struct hda_channel_mode alc883_3ST_2ch_modes[1] = {
6912         { 2, NULL }
6913 };
6914
6915 /*
6916  * 2ch mode
6917  */
6918 static struct hda_verb alc882_3ST_ch2_init[] = {
6919         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6920         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6921         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6922         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6923         { } /* end */
6924 };
6925
6926 /*
6927  * 4ch mode
6928  */
6929 static struct hda_verb alc882_3ST_ch4_init[] = {
6930         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6931         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6932         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6933         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6934         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6935         { } /* end */
6936 };
6937
6938 /*
6939  * 6ch mode
6940  */
6941 static struct hda_verb alc882_3ST_ch6_init[] = {
6942         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6943         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6944         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6945         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6946         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6947         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6948         { } /* end */
6949 };
6950
6951 static struct hda_channel_mode alc882_3ST_6ch_modes[3] = {
6952         { 2, alc882_3ST_ch2_init },
6953         { 4, alc882_3ST_ch4_init },
6954         { 6, alc882_3ST_ch6_init },
6955 };
6956
6957 #define alc883_3ST_6ch_modes    alc882_3ST_6ch_modes
6958
6959 /*
6960  * 2ch mode
6961  */
6962 static struct hda_verb alc883_3ST_ch2_clevo_init[] = {
6963         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },
6964         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6965         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6966         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
6967         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6968         { } /* end */
6969 };
6970
6971 /*
6972  * 4ch mode
6973  */
6974 static struct hda_verb alc883_3ST_ch4_clevo_init[] = {
6975         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6976         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
6977         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
6978         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6979         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6980         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6981         { } /* end */
6982 };
6983
6984 /*
6985  * 6ch mode
6986  */
6987 static struct hda_verb alc883_3ST_ch6_clevo_init[] = {
6988         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6989         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6990         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6991         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
6992         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
6993         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
6994         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
6995         { } /* end */
6996 };
6997
6998 static struct hda_channel_mode alc883_3ST_6ch_clevo_modes[3] = {
6999         { 2, alc883_3ST_ch2_clevo_init },
7000         { 4, alc883_3ST_ch4_clevo_init },
7001         { 6, alc883_3ST_ch6_clevo_init },
7002 };
7003
7004
7005 /*
7006  * 6ch mode
7007  */
7008 static struct hda_verb alc882_sixstack_ch6_init[] = {
7009         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7010         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7011         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7012         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7013         { } /* end */
7014 };
7015
7016 /*
7017  * 8ch mode
7018  */
7019 static struct hda_verb alc882_sixstack_ch8_init[] = {
7020         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7021         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7022         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7023         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7024         { } /* end */
7025 };
7026
7027 static struct hda_channel_mode alc882_sixstack_modes[2] = {
7028         { 6, alc882_sixstack_ch6_init },
7029         { 8, alc882_sixstack_ch8_init },
7030 };
7031
7032
7033 /* Macbook Air 2,1 */
7034
7035 static struct hda_channel_mode alc885_mba21_ch_modes[1] = {
7036       { 2, NULL },
7037 };
7038
7039 /*
7040  * macbook pro ALC885 can switch LineIn to LineOut without losing Mic
7041  */
7042
7043 /*
7044  * 2ch mode
7045  */
7046 static struct hda_verb alc885_mbp_ch2_init[] = {
7047         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7048         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7049         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7050         { } /* end */
7051 };
7052
7053 /*
7054  * 4ch mode
7055  */
7056 static struct hda_verb alc885_mbp_ch4_init[] = {
7057         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7058         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7059         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7060         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7061         { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7062         { } /* end */
7063 };
7064
7065 static struct hda_channel_mode alc885_mbp_4ch_modes[2] = {
7066         { 2, alc885_mbp_ch2_init },
7067         { 4, alc885_mbp_ch4_init },
7068 };
7069
7070 /*
7071  * 2ch
7072  * Speakers/Woofer/HP = Front
7073  * LineIn = Input
7074  */
7075 static struct hda_verb alc885_mb5_ch2_init[] = {
7076         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7077         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7078         { } /* end */
7079 };
7080
7081 /*
7082  * 6ch mode
7083  * Speakers/HP = Front
7084  * Woofer = LFE
7085  * LineIn = Surround
7086  */
7087 static struct hda_verb alc885_mb5_ch6_init[] = {
7088         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7089         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7090         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7091         { } /* end */
7092 };
7093
7094 static struct hda_channel_mode alc885_mb5_6ch_modes[2] = {
7095         { 2, alc885_mb5_ch2_init },
7096         { 6, alc885_mb5_ch6_init },
7097 };
7098
7099 #define alc885_macmini3_6ch_modes       alc885_mb5_6ch_modes
7100
7101 /*
7102  * 2ch mode
7103  */
7104 static struct hda_verb alc883_4ST_ch2_init[] = {
7105         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7106         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7107         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7108         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7109         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7110         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7111         { } /* end */
7112 };
7113
7114 /*
7115  * 4ch mode
7116  */
7117 static struct hda_verb alc883_4ST_ch4_init[] = {
7118         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7119         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7120         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7121         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7122         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7123         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7124         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7125         { } /* end */
7126 };
7127
7128 /*
7129  * 6ch mode
7130  */
7131 static struct hda_verb alc883_4ST_ch6_init[] = {
7132         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7133         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7134         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7135         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7136         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7137         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7138         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7139         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7140         { } /* end */
7141 };
7142
7143 /*
7144  * 8ch mode
7145  */
7146 static struct hda_verb alc883_4ST_ch8_init[] = {
7147         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7148         { 0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7149         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7150         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7151         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7152         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
7153         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7154         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7155         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7156         { } /* end */
7157 };
7158
7159 static struct hda_channel_mode alc883_4ST_8ch_modes[4] = {
7160         { 2, alc883_4ST_ch2_init },
7161         { 4, alc883_4ST_ch4_init },
7162         { 6, alc883_4ST_ch6_init },
7163         { 8, alc883_4ST_ch8_init },
7164 };
7165
7166
7167 /*
7168  * 2ch mode
7169  */
7170 static struct hda_verb alc883_3ST_ch2_intel_init[] = {
7171         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7172         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7173         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7174         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7175         { } /* end */
7176 };
7177
7178 /*
7179  * 4ch mode
7180  */
7181 static struct hda_verb alc883_3ST_ch4_intel_init[] = {
7182         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
7183         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7184         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7185         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7186         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7187         { } /* end */
7188 };
7189
7190 /*
7191  * 6ch mode
7192  */
7193 static struct hda_verb alc883_3ST_ch6_intel_init[] = {
7194         { 0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7195         { 0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7196         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x02 },
7197         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7198         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7199         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
7200         { } /* end */
7201 };
7202
7203 static struct hda_channel_mode alc883_3ST_6ch_intel_modes[3] = {
7204         { 2, alc883_3ST_ch2_intel_init },
7205         { 4, alc883_3ST_ch4_intel_init },
7206         { 6, alc883_3ST_ch6_intel_init },
7207 };
7208
7209 /*
7210  * 2ch mode
7211  */
7212 static struct hda_verb alc889_ch2_intel_init[] = {
7213         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7214         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x00 },
7215         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x00 },
7216         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x00 },
7217         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7218         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7219         { } /* end */
7220 };
7221
7222 /*
7223  * 6ch mode
7224  */
7225 static struct hda_verb alc889_ch6_intel_init[] = {
7226         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7227         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7228         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7229         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7230         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
7231         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
7232         { } /* end */
7233 };
7234
7235 /*
7236  * 8ch mode
7237  */
7238 static struct hda_verb alc889_ch8_intel_init[] = {
7239         { 0x14, AC_VERB_SET_CONNECT_SEL, 0x00 },
7240         { 0x19, AC_VERB_SET_CONNECT_SEL, 0x01 },
7241         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x02 },
7242         { 0x17, AC_VERB_SET_CONNECT_SEL, 0x03 },
7243         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x03 },
7244         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7245         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
7246         { } /* end */
7247 };
7248
7249 static struct hda_channel_mode alc889_8ch_intel_modes[3] = {
7250         { 2, alc889_ch2_intel_init },
7251         { 6, alc889_ch6_intel_init },
7252         { 8, alc889_ch8_intel_init },
7253 };
7254
7255 /*
7256  * 6ch mode
7257  */
7258 static struct hda_verb alc883_sixstack_ch6_init[] = {
7259         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
7260         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7261         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7262         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7263         { } /* end */
7264 };
7265
7266 /*
7267  * 8ch mode
7268  */
7269 static struct hda_verb alc883_sixstack_ch8_init[] = {
7270         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7271         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7272         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7273         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
7274         { } /* end */
7275 };
7276
7277 static struct hda_channel_mode alc883_sixstack_modes[2] = {
7278         { 6, alc883_sixstack_ch6_init },
7279         { 8, alc883_sixstack_ch8_init },
7280 };
7281
7282
7283 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
7284  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
7285  */
7286 static struct snd_kcontrol_new alc882_base_mixer[] = {
7287         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7288         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7289         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
7290         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
7291         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
7292         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
7293         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
7294         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
7295         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
7296         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
7297         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7298         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7299         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7300         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7301         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7302         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7303         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7304         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7305         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7306         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7307         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7308         { } /* end */
7309 };
7310
7311 /* Macbook Air 2,1 same control for HP and internal Speaker */
7312
7313 static struct snd_kcontrol_new alc885_mba21_mixer[] = {
7314       HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7315       HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 0x02, HDA_OUTPUT),
7316      { }
7317 };
7318
7319
7320 static struct snd_kcontrol_new alc885_mbp3_mixer[] = {
7321         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7322         HDA_BIND_MUTE   ("Speaker Playback Switch", 0x0c, 0x02, HDA_INPUT),
7323         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7324         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0e, 0x02, HDA_INPUT),
7325         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7326         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7327         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7328         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7329         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7330         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
7331         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7332         { } /* end */
7333 };
7334
7335 static struct snd_kcontrol_new alc885_mb5_mixer[] = {
7336         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7337         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7338         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7339         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7340         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7341         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7342         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7343         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7344         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7345         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7346         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
7347         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
7348         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7349         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0x00, HDA_INPUT),
7350         { } /* end */
7351 };
7352
7353 static struct snd_kcontrol_new alc885_macmini3_mixer[] = {
7354         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7355         HDA_BIND_MUTE   ("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
7356         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7357         HDA_BIND_MUTE   ("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
7358         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0e, 0x00, HDA_OUTPUT),
7359         HDA_BIND_MUTE   ("LFE Playback Switch", 0x0e, 0x02, HDA_INPUT),
7360         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0f, 0x00, HDA_OUTPUT),
7361         HDA_BIND_MUTE   ("Headphone Playback Switch", 0x0f, 0x02, HDA_INPUT),
7362         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x07, HDA_INPUT),
7363         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x07, HDA_INPUT),
7364         HDA_CODEC_VOLUME("Line Boost", 0x15, 0x00, HDA_INPUT),
7365         { } /* end */
7366 };
7367
7368 static struct snd_kcontrol_new alc885_imac91_mixer[] = {
7369         HDA_CODEC_VOLUME("Line-Out Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7370         HDA_BIND_MUTE   ("Line-Out Playback Switch", 0x0c, 0x02, HDA_INPUT),
7371         HDA_CODEC_MUTE  ("Speaker Playback Switch", 0x14, 0x00, HDA_OUTPUT),
7372         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
7373         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7374         HDA_CODEC_MUTE  ("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7375         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
7376         HDA_CODEC_MUTE  ("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
7377         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
7378         { } /* end */
7379 };
7380
7381
7382 static struct snd_kcontrol_new alc882_w2jc_mixer[] = {
7383         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7384         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7385         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7386         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7387         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7388         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7389         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7390         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7391         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7392         { } /* end */
7393 };
7394
7395 static struct snd_kcontrol_new alc882_targa_mixer[] = {
7396         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7397         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7398         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
7399         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7400         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7401         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7402         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7403         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7404         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7405         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7406         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
7407         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
7408         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
7409         { } /* end */
7410 };
7411
7412 /* Pin assignment: Front=0x14, HP = 0x15, Front = 0x16, ???
7413  *                 Front Mic=0x18, Line In = 0x1a, Line In = 0x1b, CD = 0x1c
7414  */
7415 static struct snd_kcontrol_new alc882_asus_a7j_mixer[] = {
7416         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7417         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
7418         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7419         HDA_CODEC_MUTE("Mobile Front Playback Switch", 0x16, 0x0, HDA_OUTPUT),
7420         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7421         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7422         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7423         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7424         HDA_CODEC_VOLUME("Mobile Line Playback Volume", 0x0b, 0x03, HDA_INPUT),
7425         HDA_CODEC_MUTE("Mobile Line Playback Switch", 0x0b, 0x03, HDA_INPUT),
7426         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7427         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7428         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7429         { } /* end */
7430 };
7431
7432 static struct snd_kcontrol_new alc882_asus_a7m_mixer[] = {
7433         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7434         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7435         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
7436         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
7437         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
7438         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
7439         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
7440         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
7441         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
7442         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
7443         { } /* end */
7444 };
7445
7446 static struct snd_kcontrol_new alc882_chmode_mixer[] = {
7447         {
7448                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
7449                 .name = "Channel Mode",
7450                 .info = alc_ch_mode_info,
7451                 .get = alc_ch_mode_get,
7452                 .put = alc_ch_mode_put,
7453         },
7454         { } /* end */
7455 };
7456
7457 static struct hda_verb alc882_base_init_verbs[] = {
7458         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7459         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7460         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7461         /* Rear mixer */
7462         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7463         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7464         /* CLFE mixer */
7465         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7466         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7467         /* Side mixer */
7468         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7469         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7470
7471         /* Front Pin: output 0 (0x0c) */
7472         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7473         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7474         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7475         /* Rear Pin: output 1 (0x0d) */
7476         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7477         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7478         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
7479         /* CLFE Pin: output 2 (0x0e) */
7480         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7481         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7482         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7483         /* Side Pin: output 3 (0x0f) */
7484         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7485         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7486         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7487         /* Mic (rear) pin: input vref at 80% */
7488         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7489         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7490         /* Front Mic pin: input vref at 80% */
7491         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7492         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7493         /* Line In pin: input */
7494         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7495         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7496         /* Line-2 In: Headphone output (output 0 - 0x0c) */
7497         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7498         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7499         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
7500         /* CD pin widget for input */
7501         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7502
7503         /* FIXME: use matrix-type input source selection */
7504         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7505         /* Input mixer2 */
7506         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7507         /* Input mixer3 */
7508         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7509         /* ADC2: mute amp left and right */
7510         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7511         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7512         /* ADC3: mute amp left and right */
7513         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7514         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7515
7516         { }
7517 };
7518
7519 static struct hda_verb alc882_adc1_init_verbs[] = {
7520         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7521         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7522         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7523         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7524         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7525         /* ADC1: mute amp left and right */
7526         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7527         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7528         { }
7529 };
7530
7531 static struct hda_verb alc882_eapd_verbs[] = {
7532         /* change to EAPD mode */
7533         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
7534         {0x20, AC_VERB_SET_PROC_COEF, 0x3060},
7535         { }
7536 };
7537
7538 static struct hda_verb alc889_eapd_verbs[] = {
7539         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
7540         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
7541         { }
7542 };
7543
7544 static struct hda_verb alc_hp15_unsol_verbs[] = {
7545         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
7546         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7547         {}
7548 };
7549
7550 static struct hda_verb alc885_init_verbs[] = {
7551         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7552         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7553         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7554         /* Rear mixer */
7555         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7556         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7557         /* CLFE mixer */
7558         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7559         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7560         /* Side mixer */
7561         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7562         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7563
7564         /* Front HP Pin: output 0 (0x0c) */
7565         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7566         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7567         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7568         /* Front Pin: output 0 (0x0c) */
7569         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7570         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7571         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7572         /* Rear Pin: output 1 (0x0d) */
7573         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7574         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7575         {0x19, AC_VERB_SET_CONNECT_SEL, 0x01},
7576         /* CLFE Pin: output 2 (0x0e) */
7577         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7578         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7579         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
7580         /* Side Pin: output 3 (0x0f) */
7581         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7582         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7583         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
7584         /* Mic (rear) pin: input vref at 80% */
7585         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7586         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7587         /* Front Mic pin: input vref at 80% */
7588         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7589         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7590         /* Line In pin: input */
7591         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7592         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7593
7594         /* Mixer elements: 0x18, , 0x1a, 0x1b */
7595         /* Input mixer1 */
7596         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7597         /* Input mixer2 */
7598         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7599         /* Input mixer3 */
7600         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7601         /* ADC2: mute amp left and right */
7602         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7603         /* ADC3: mute amp left and right */
7604         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7605
7606         { }
7607 };
7608
7609 static struct hda_verb alc885_init_input_verbs[] = {
7610         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7611         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
7612         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
7613         { }
7614 };
7615
7616
7617 /* Unmute Selector 24h and set the default input to front mic */
7618 static struct hda_verb alc889_init_input_verbs[] = {
7619         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
7620         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7621         { }
7622 };
7623
7624
7625 #define alc883_init_verbs       alc882_base_init_verbs
7626
7627 /* Mac Pro test */
7628 static struct snd_kcontrol_new alc882_macpro_mixer[] = {
7629         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
7630         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
7631         HDA_CODEC_MUTE("Headphone Playback Switch", 0x18, 0x0, HDA_OUTPUT),
7632         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
7633         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
7634         /* FIXME: this looks suspicious...
7635         HDA_CODEC_VOLUME("Beep Playback Volume", 0x0b, 0x02, HDA_INPUT),
7636         HDA_CODEC_MUTE("Beep Playback Switch", 0x0b, 0x02, HDA_INPUT),
7637         */
7638         { } /* end */
7639 };
7640
7641 static struct hda_verb alc882_macpro_init_verbs[] = {
7642         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7643         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7644         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7645         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7646         /* Front Pin: output 0 (0x0c) */
7647         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7648         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7649         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7650         /* Front Mic pin: input vref at 80% */
7651         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7652         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7653         /* Speaker:  output */
7654         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7655         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7656         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x04},
7657         /* Headphone output (output 0 - 0x0c) */
7658         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7659         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7660         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7661
7662         /* FIXME: use matrix-type input source selection */
7663         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7664         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7665         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7666         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7667         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7668         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7669         /* Input mixer2 */
7670         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7671         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7672         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7673         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7674         /* Input mixer3 */
7675         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7676         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7677         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7678         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7679         /* ADC1: mute amp left and right */
7680         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7681         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7682         /* ADC2: mute amp left and right */
7683         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7684         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7685         /* ADC3: mute amp left and right */
7686         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7687         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7688
7689         { }
7690 };
7691
7692 /* Macbook 5,1 */
7693 static struct hda_verb alc885_mb5_init_verbs[] = {
7694         /* DACs */
7695         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7696         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7697         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7698         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7699         /* Front mixer */
7700         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7701         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7702         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7703         /* Surround mixer */
7704         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7705         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7706         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7707         /* LFE mixer */
7708         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7709         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7710         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7711         /* HP mixer */
7712         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7713         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7714         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7715         /* Front Pin (0x0c) */
7716         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7717         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7718         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7719         /* LFE Pin (0x0e) */
7720         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7721         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7722         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7723         /* HP Pin (0x0f) */
7724         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7725         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7726         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7727         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7728         /* Front Mic pin: input vref at 80% */
7729         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7730         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7731         /* Line In pin */
7732         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7733         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7734
7735         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7736         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7737         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7738         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7739         { }
7740 };
7741
7742 /* Macmini 3,1 */
7743 static struct hda_verb alc885_macmini3_init_verbs[] = {
7744         /* DACs */
7745         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7746         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7747         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7748         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7749         /* Front mixer */
7750         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7751         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7752         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7753         /* Surround mixer */
7754         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7755         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7756         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7757         /* LFE mixer */
7758         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7759         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7760         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7761         /* HP mixer */
7762         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7763         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7764         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7765         /* Front Pin (0x0c) */
7766         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7767         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7768         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7769         /* LFE Pin (0x0e) */
7770         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT | 0x01},
7771         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7772         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},
7773         /* HP Pin (0x0f) */
7774         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7775         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7776         {0x14, AC_VERB_SET_CONNECT_SEL, 0x03},
7777         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7778         /* Line In pin */
7779         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7780         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7781
7782         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7783         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7784         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7785         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7786         { }
7787 };
7788
7789
7790 static struct hda_verb alc885_mba21_init_verbs[] = {
7791         /*Internal and HP Speaker Mixer*/
7792         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7793         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7794         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
7795         /*Internal Speaker Pin (0x0c)*/
7796         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, (PIN_OUT | AC_PINCTL_VREF_50) },
7797         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7798         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7799         /* HP Pin: output 0 (0x0e) */
7800         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7801         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7802         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7803         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, (ALC880_HP_EVENT | AC_USRSP_EN)},
7804         /* Line in (is hp when jack connected)*/
7805         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, AC_PINCTL_VREF_50},
7806         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7807
7808         { }
7809  };
7810
7811
7812 /* Macbook Pro rev3 */
7813 static struct hda_verb alc885_mbp3_init_verbs[] = {
7814         /* Front mixer: unmute input/output amp left and right (volume = 0) */
7815         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7816         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7817         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7818         /* Rear mixer */
7819         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7820         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7821         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7822         /* HP mixer */
7823         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7824         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7825         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7826         /* Front Pin: output 0 (0x0c) */
7827         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7828         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7829         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7830         /* HP Pin: output 0 (0x0e) */
7831         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},
7832         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7833         {0x15, AC_VERB_SET_CONNECT_SEL, 0x02},
7834         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7835         /* Mic (rear) pin: input vref at 80% */
7836         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7837         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7838         /* Front Mic pin: input vref at 80% */
7839         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7840         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7841         /* Line In pin: use output 1 when in LineOut mode */
7842         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7843         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7844         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7845
7846         /* FIXME: use matrix-type input source selection */
7847         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7848         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7849         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7850         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7851         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7852         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7853         /* Input mixer2 */
7854         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7855         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7856         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7857         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7858         /* Input mixer3 */
7859         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7860         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7861         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7862         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7863         /* ADC1: mute amp left and right */
7864         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7865         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7866         /* ADC2: mute amp left and right */
7867         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7868         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7869         /* ADC3: mute amp left and right */
7870         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7871         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7872
7873         { }
7874 };
7875
7876 /* iMac 9,1 */
7877 static struct hda_verb alc885_imac91_init_verbs[] = {
7878         /* Line-Out mixer: unmute input/output amp left and right (volume = 0) */
7879         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7880         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7881         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7882         /* Rear mixer */
7883         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
7884         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7885         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
7886         /* HP Pin: output 0 (0x0c) */
7887         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7888         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7889         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7890         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7891         /* Internal Speakers: output 0 (0x0d) */
7892         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7893         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7894         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
7895         /* Mic (rear) pin: input vref at 80% */
7896         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7897         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7898         /* Front Mic pin: input vref at 80% */
7899         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7900         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7901         /* Line In pin: use output 1 when in LineOut mode */
7902         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
7903         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7904         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
7905
7906         /* FIXME: use matrix-type input source selection */
7907         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
7908         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
7909         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7910         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7911         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7912         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7913         /* Input mixer2 */
7914         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7915         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7916         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7917         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7918         /* Input mixer3 */
7919         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
7920         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
7921         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
7922         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
7923         /* ADC1: mute amp left and right */
7924         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7925         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
7926         /* ADC2: mute amp left and right */
7927         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7928         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
7929         /* ADC3: mute amp left and right */
7930         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
7931         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
7932
7933         { }
7934 };
7935
7936 /* iMac 24 mixer. */
7937 static struct snd_kcontrol_new alc885_imac24_mixer[] = {
7938         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
7939         HDA_CODEC_MUTE("Master Playback Switch", 0x0c, 0x00, HDA_INPUT),
7940         { } /* end */
7941 };
7942
7943 /* iMac 24 init verbs. */
7944 static struct hda_verb alc885_imac24_init_verbs[] = {
7945         /* Internal speakers: output 0 (0x0c) */
7946         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7947         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7948         {0x18, AC_VERB_SET_CONNECT_SEL, 0x00},
7949         /* Internal speakers: output 0 (0x0c) */
7950         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
7951         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7952         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
7953         /* Headphone: output 0 (0x0c) */
7954         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
7955         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
7956         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
7957         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
7958         /* Front Mic: input vref at 80% */
7959         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
7960         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
7961         { }
7962 };
7963
7964 /* Toggle speaker-output according to the hp-jack state */
7965 static void alc885_imac24_setup(struct hda_codec *codec)
7966 {
7967         struct alc_spec *spec = codec->spec;
7968
7969         spec->autocfg.hp_pins[0] = 0x14;
7970         spec->autocfg.speaker_pins[0] = 0x18;
7971         spec->autocfg.speaker_pins[1] = 0x1a;
7972 }
7973
7974 #define alc885_mb5_setup        alc885_imac24_setup
7975 #define alc885_macmini3_setup   alc885_imac24_setup
7976
7977 /* Macbook Air 2,1 */
7978 static void alc885_mba21_setup(struct hda_codec *codec)
7979 {
7980        struct alc_spec *spec = codec->spec;
7981
7982        spec->autocfg.hp_pins[0] = 0x14;
7983        spec->autocfg.speaker_pins[0] = 0x18;
7984 }
7985
7986
7987
7988 static void alc885_mbp3_setup(struct hda_codec *codec)
7989 {
7990         struct alc_spec *spec = codec->spec;
7991
7992         spec->autocfg.hp_pins[0] = 0x15;
7993         spec->autocfg.speaker_pins[0] = 0x14;
7994 }
7995
7996 static void alc885_imac91_setup(struct hda_codec *codec)
7997 {
7998         struct alc_spec *spec = codec->spec;
7999
8000         spec->autocfg.hp_pins[0] = 0x14;
8001         spec->autocfg.speaker_pins[0] = 0x15;
8002         spec->autocfg.speaker_pins[1] = 0x1a;
8003 }
8004
8005 static struct hda_verb alc882_targa_verbs[] = {
8006         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8007         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8008
8009         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8010         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8011
8012         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8013         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8014         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8015
8016         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8017         { } /* end */
8018 };
8019
8020 /* toggle speaker-output according to the hp-jack state */
8021 static void alc882_targa_automute(struct hda_codec *codec)
8022 {
8023         struct alc_spec *spec = codec->spec;
8024         alc_automute_amp(codec);
8025         snd_hda_codec_write_cache(codec, 1, 0, AC_VERB_SET_GPIO_DATA,
8026                                   spec->jack_present ? 1 : 3);
8027 }
8028
8029 static void alc882_targa_setup(struct hda_codec *codec)
8030 {
8031         struct alc_spec *spec = codec->spec;
8032
8033         spec->autocfg.hp_pins[0] = 0x14;
8034         spec->autocfg.speaker_pins[0] = 0x1b;
8035 }
8036
8037 static void alc882_targa_unsol_event(struct hda_codec *codec, unsigned int res)
8038 {
8039         if ((res >> 26) == ALC880_HP_EVENT)
8040                 alc882_targa_automute(codec);
8041 }
8042
8043 static struct hda_verb alc882_asus_a7j_verbs[] = {
8044         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8045         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8046
8047         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8048         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8049         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8050
8051         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8052         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8053         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8054
8055         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8056         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8057         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8058         { } /* end */
8059 };
8060
8061 static struct hda_verb alc882_asus_a7m_verbs[] = {
8062         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8063         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8064
8065         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8066         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8067         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8068
8069         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8070         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8071         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00}, /* Front */
8072
8073         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02}, /* mic/clfe */
8074         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01}, /* line/surround */
8075         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00}, /* HP */
8076         { } /* end */
8077 };
8078
8079 static void alc882_gpio_mute(struct hda_codec *codec, int pin, int muted)
8080 {
8081         unsigned int gpiostate, gpiomask, gpiodir;
8082
8083         gpiostate = snd_hda_codec_read(codec, codec->afg, 0,
8084                                        AC_VERB_GET_GPIO_DATA, 0);
8085
8086         if (!muted)
8087                 gpiostate |= (1 << pin);
8088         else
8089                 gpiostate &= ~(1 << pin);
8090
8091         gpiomask = snd_hda_codec_read(codec, codec->afg, 0,
8092                                       AC_VERB_GET_GPIO_MASK, 0);
8093         gpiomask |= (1 << pin);
8094
8095         gpiodir = snd_hda_codec_read(codec, codec->afg, 0,
8096                                      AC_VERB_GET_GPIO_DIRECTION, 0);
8097         gpiodir |= (1 << pin);
8098
8099
8100         snd_hda_codec_write(codec, codec->afg, 0,
8101                             AC_VERB_SET_GPIO_MASK, gpiomask);
8102         snd_hda_codec_write(codec, codec->afg, 0,
8103                             AC_VERB_SET_GPIO_DIRECTION, gpiodir);
8104
8105         msleep(1);
8106
8107         snd_hda_codec_write(codec, codec->afg, 0,
8108                             AC_VERB_SET_GPIO_DATA, gpiostate);
8109 }
8110
8111 /* set up GPIO at initialization */
8112 static void alc885_macpro_init_hook(struct hda_codec *codec)
8113 {
8114         alc882_gpio_mute(codec, 0, 0);
8115         alc882_gpio_mute(codec, 1, 0);
8116 }
8117
8118 /* set up GPIO and update auto-muting at initialization */
8119 static void alc885_imac24_init_hook(struct hda_codec *codec)
8120 {
8121         alc885_macpro_init_hook(codec);
8122         alc_automute_amp(codec);
8123 }
8124
8125 /*
8126  * generic initialization of ADC, input mixers and output mixers
8127  */
8128 static struct hda_verb alc883_auto_init_verbs[] = {
8129         /*
8130          * Unmute ADC0-2 and set the default input to mic-in
8131          */
8132         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
8133         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8134         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
8135         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8136
8137         /*
8138          * Set up output mixers (0x0c - 0x0f)
8139          */
8140         /* set vol=0 to output mixers */
8141         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8142         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8143         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8144         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
8145         /* set up input amps for analog loopback */
8146         /* Amp Indices: DAC = 0, mixer = 1 */
8147         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8148         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8149         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8150         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8151         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8152         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8153         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8154         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8155         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8156         {0x26, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8157
8158         /* FIXME: use matrix-type input source selection */
8159         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
8160         /* Input mixer2 */
8161         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8162         /* Input mixer3 */
8163         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8164         { }
8165 };
8166
8167 /* 2ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:front) */
8168 static struct hda_verb alc889A_mb31_ch2_init[] = {
8169         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8170         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8171         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8172         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8173         { } /* end */
8174 };
8175
8176 /* 4ch mode (Speaker:front, Subwoofer:CLFE, Line:CLFE, Headphones:front) */
8177 static struct hda_verb alc889A_mb31_ch4_init[] = {
8178         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},             /* HP as front */
8179         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8180         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8181         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8182         { } /* end */
8183 };
8184
8185 /* 5ch mode (Speaker:front, Subwoofer:CLFE, Line:input, Headphones:rear) */
8186 static struct hda_verb alc889A_mb31_ch5_init[] = {
8187         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as rear */
8188         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Subwoofer on */
8189         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},    /* Line as input */
8190         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Line off */
8191         { } /* end */
8192 };
8193
8194 /* 6ch mode (Speaker:front, Subwoofer:off, Line:CLFE, Headphones:Rear) */
8195 static struct hda_verb alc889A_mb31_ch6_init[] = {
8196         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},             /* HP as front */
8197         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},   /* Subwoofer off */
8198         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},   /* Line as output */
8199         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, /* Line on */
8200         { } /* end */
8201 };
8202
8203 static struct hda_channel_mode alc889A_mb31_6ch_modes[4] = {
8204         { 2, alc889A_mb31_ch2_init },
8205         { 4, alc889A_mb31_ch4_init },
8206         { 5, alc889A_mb31_ch5_init },
8207         { 6, alc889A_mb31_ch6_init },
8208 };
8209
8210 static struct hda_verb alc883_medion_eapd_verbs[] = {
8211         /* eanable EAPD on medion laptop */
8212         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
8213         {0x20, AC_VERB_SET_PROC_COEF, 0x3070},
8214         { }
8215 };
8216
8217 #define alc883_base_mixer       alc882_base_mixer
8218
8219 static struct snd_kcontrol_new alc883_mitac_mixer[] = {
8220         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8221         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8222         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8223         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8224         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8225         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8226         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8227         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8228         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8229         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8230         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8231         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8232         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8233         { } /* end */
8234 };
8235
8236 static struct snd_kcontrol_new alc883_clevo_m720_mixer[] = {
8237         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8238         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8239         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8240         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8241         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8242         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8243         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8244         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8245         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8246         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8247         { } /* end */
8248 };
8249
8250 static struct snd_kcontrol_new alc883_2ch_fujitsu_pi2515_mixer[] = {
8251         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8252         HDA_BIND_MUTE("Headphone Playback Switch", 0x0c, 2, HDA_INPUT),
8253         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8254         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8255         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8256         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8257         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8258         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8259         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8260         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8261         { } /* end */
8262 };
8263
8264 static struct snd_kcontrol_new alc883_3ST_2ch_mixer[] = {
8265         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8266         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8267         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8268         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8269         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8270         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8271         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8272         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8273         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8274         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8275         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8276         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8277         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8278         { } /* end */
8279 };
8280
8281 static struct snd_kcontrol_new alc883_3ST_6ch_mixer[] = {
8282         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8283         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8284         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8285         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8286         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8287         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8288         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8289         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8290         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8291         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8292         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8293         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8294         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8295         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8296         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8297         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8298         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8299         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8300         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8301         { } /* end */
8302 };
8303
8304 static struct snd_kcontrol_new alc883_3ST_6ch_intel_mixer[] = {
8305         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8306         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8307         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8308         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8309         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8310                               HDA_OUTPUT),
8311         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8312         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8313         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8314         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8315         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8316         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8317         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8318         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8319         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8320         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8321         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8322         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8323         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8324         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8325         { } /* end */
8326 };
8327
8328 static struct snd_kcontrol_new alc885_8ch_intel_mixer[] = {
8329         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8330         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8331         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8332         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8333         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0,
8334                               HDA_OUTPUT),
8335         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8336         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8337         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8338         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8339         HDA_BIND_MUTE("Speaker Playback Switch", 0x0f, 2, HDA_INPUT),
8340         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8341         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8342         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8343         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x3, HDA_INPUT),
8344         HDA_CODEC_VOLUME("Mic Boost", 0x1b, 0, HDA_INPUT),
8345         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x3, HDA_INPUT),
8346         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8347         HDA_CODEC_VOLUME("Front Mic Boost", 0x18, 0, HDA_INPUT),
8348         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8349         { } /* end */
8350 };
8351
8352 static struct snd_kcontrol_new alc883_fivestack_mixer[] = {
8353         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8354         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8355         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8356         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8357         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8358         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8359         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8360         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8361         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8362         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8363         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8364         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8365         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8366         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8367         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8368         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8369         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8370         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8371         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8372         { } /* end */
8373 };
8374
8375 static struct snd_kcontrol_new alc883_targa_mixer[] = {
8376         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8377         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8378         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8379         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8380         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8381         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
8382         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
8383         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
8384         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
8385         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
8386         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8387         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8388         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8389         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8390         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8391         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8392         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8393         { } /* end */
8394 };
8395
8396 static struct snd_kcontrol_new alc883_targa_2ch_mixer[] = {
8397         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8398         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8399         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8400         HDA_CODEC_MUTE("Speaker Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8401         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8402         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8403         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8404         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8405         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8406         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8407         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8408         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8409         { } /* end */
8410 };
8411
8412 static struct snd_kcontrol_new alc883_targa_8ch_mixer[] = {
8413         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8414         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8415         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8416         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
8417         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8418         { } /* end */
8419 };
8420
8421 static struct snd_kcontrol_new alc883_lenovo_101e_2ch_mixer[] = {
8422         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8423         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8424         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
8425         HDA_BIND_MUTE("Speaker Playback Switch", 0x0d, 2, HDA_INPUT),
8426         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
8427         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8428         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8429         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8430         { } /* end */
8431 };
8432
8433 static struct snd_kcontrol_new alc883_lenovo_nb0763_mixer[] = {
8434         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8435         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
8436         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8437         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8438         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8439         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8440         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8441         HDA_CODEC_VOLUME("iMic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8442         HDA_CODEC_MUTE("iMic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8443         { } /* end */
8444 };
8445
8446 static struct snd_kcontrol_new alc883_medion_md2_mixer[] = {
8447         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8448         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8449         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8450         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8451         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8452         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8453         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8454         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8455         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8456         { } /* end */
8457 };
8458
8459 static struct snd_kcontrol_new alc883_medion_wim2160_mixer[] = {
8460         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8461         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8462         HDA_CODEC_MUTE("Speaker Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8463         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x0, HDA_OUTPUT),
8464         HDA_CODEC_VOLUME("Line Playback Volume", 0x08, 0x0, HDA_INPUT),
8465         HDA_CODEC_MUTE("Line Playback Switch", 0x08, 0x0, HDA_INPUT),
8466         { } /* end */
8467 };
8468
8469 static struct hda_verb alc883_medion_wim2160_verbs[] = {
8470         /* Unmute front mixer */
8471         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8472         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8473
8474         /* Set speaker pin to front mixer */
8475         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8476
8477         /* Init headphone pin */
8478         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8479         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8480         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8481         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8482
8483         { } /* end */
8484 };
8485
8486 /* toggle speaker-output according to the hp-jack state */
8487 static void alc883_medion_wim2160_setup(struct hda_codec *codec)
8488 {
8489         struct alc_spec *spec = codec->spec;
8490
8491         spec->autocfg.hp_pins[0] = 0x1a;
8492         spec->autocfg.speaker_pins[0] = 0x15;
8493 }
8494
8495 static struct snd_kcontrol_new alc883_acer_aspire_mixer[] = {
8496         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8497         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8498         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8499         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8500         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8501         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8502         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8503         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8504         { } /* end */
8505 };
8506
8507 static struct snd_kcontrol_new alc888_acer_aspire_6530_mixer[] = {
8508         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8509         HDA_CODEC_VOLUME("LFE Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8510         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8511         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8512         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8513         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8515         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8516         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8517         { } /* end */
8518 };
8519
8520 static struct snd_kcontrol_new alc888_lenovo_sky_mixer[] = {
8521         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8522         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8523         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
8524         HDA_BIND_MUTE("Surround Playback Switch", 0x0e, 2, HDA_INPUT),
8525         HDA_CODEC_VOLUME_MONO("Center Playback Volume",
8526                                                 0x0d, 1, 0x0, HDA_OUTPUT),
8527         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0d, 2, 0x0, HDA_OUTPUT),
8528         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0d, 1, 2, HDA_INPUT),
8529         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0d, 2, 2, HDA_INPUT),
8530         HDA_CODEC_VOLUME("Side Playback Volume", 0x0f, 0x0, HDA_OUTPUT),
8531         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
8532         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
8533         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
8534         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8535         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8536         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8537         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8538         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8539         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8540         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
8541         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8542         { } /* end */
8543 };
8544
8545 static struct snd_kcontrol_new alc889A_mb31_mixer[] = {
8546         /* Output mixers */
8547         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x00, HDA_OUTPUT),
8548         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 0x02, HDA_INPUT),
8549         HDA_CODEC_VOLUME("Surround Playback Volume", 0x0d, 0x00, HDA_OUTPUT),
8550         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 0x02, HDA_INPUT),
8551         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x0e, 1, 0x00,
8552                 HDA_OUTPUT),
8553         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x02, HDA_INPUT),
8554         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x0e, 2, 0x00, HDA_OUTPUT),
8555         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x02, HDA_INPUT),
8556         /* Output switches */
8557         HDA_CODEC_MUTE("Enable Speaker", 0x14, 0x00, HDA_OUTPUT),
8558         HDA_CODEC_MUTE("Enable Headphones", 0x15, 0x00, HDA_OUTPUT),
8559         HDA_CODEC_MUTE_MONO("Enable LFE", 0x16, 2, 0x00, HDA_OUTPUT),
8560         /* Boost mixers */
8561         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0x00, HDA_INPUT),
8562         HDA_CODEC_VOLUME("Line Boost", 0x1a, 0x00, HDA_INPUT),
8563         /* Input mixers */
8564         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x00, HDA_INPUT),
8565         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x00, HDA_INPUT),
8566         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8567         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8568         { } /* end */
8569 };
8570
8571 static struct snd_kcontrol_new alc883_vaiott_mixer[] = {
8572         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8573         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8574         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
8575         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
8576         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
8577         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
8578         { } /* end */
8579 };
8580
8581 static struct hda_bind_ctls alc883_bind_cap_vol = {
8582         .ops = &snd_hda_bind_vol,
8583         .values = {
8584                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8585                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8586                 0
8587         },
8588 };
8589
8590 static struct hda_bind_ctls alc883_bind_cap_switch = {
8591         .ops = &snd_hda_bind_sw,
8592         .values = {
8593                 HDA_COMPOSE_AMP_VAL(0x08, 3, 0, HDA_INPUT),
8594                 HDA_COMPOSE_AMP_VAL(0x09, 3, 0, HDA_INPUT),
8595                 0
8596         },
8597 };
8598
8599 static struct snd_kcontrol_new alc883_asus_eee1601_mixer[] = {
8600         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
8601         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
8602         HDA_CODEC_MUTE("Headphone Playback Switch", 0x14, 0x0, HDA_OUTPUT),
8603         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
8604         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
8605         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
8606         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
8607         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
8608         { } /* end */
8609 };
8610
8611 static struct snd_kcontrol_new alc883_asus_eee1601_cap_mixer[] = {
8612         HDA_BIND_VOL("Capture Volume", &alc883_bind_cap_vol),
8613         HDA_BIND_SW("Capture Switch", &alc883_bind_cap_switch),
8614         {
8615                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8616                 /* .name = "Capture Source", */
8617                 .name = "Input Source",
8618                 .count = 1,
8619                 .info = alc_mux_enum_info,
8620                 .get = alc_mux_enum_get,
8621                 .put = alc_mux_enum_put,
8622         },
8623         { } /* end */
8624 };
8625
8626 static struct snd_kcontrol_new alc883_chmode_mixer[] = {
8627         {
8628                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
8629                 .name = "Channel Mode",
8630                 .info = alc_ch_mode_info,
8631                 .get = alc_ch_mode_get,
8632                 .put = alc_ch_mode_put,
8633         },
8634         { } /* end */
8635 };
8636
8637 /* toggle speaker-output according to the hp-jack state */
8638 static void alc883_mitac_setup(struct hda_codec *codec)
8639 {
8640         struct alc_spec *spec = codec->spec;
8641
8642         spec->autocfg.hp_pins[0] = 0x15;
8643         spec->autocfg.speaker_pins[0] = 0x14;
8644         spec->autocfg.speaker_pins[1] = 0x17;
8645 }
8646
8647 /* auto-toggle front mic */
8648 /*
8649 static void alc883_mitac_mic_automute(struct hda_codec *codec)
8650 {
8651         unsigned char bits = snd_hda_jack_detect(codec, 0x18) ? HDA_AMP_MUTE : 0;
8652
8653         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1, HDA_AMP_MUTE, bits);
8654 }
8655 */
8656
8657 static struct hda_verb alc883_mitac_verbs[] = {
8658         /* HP */
8659         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8660         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8661         /* Subwoofer */
8662         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
8663         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8664
8665         /* enable unsolicited event */
8666         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8667         /* {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN}, */
8668
8669         { } /* end */
8670 };
8671
8672 static struct hda_verb alc883_clevo_m540r_verbs[] = {
8673         /* HP */
8674         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8675         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8676         /* Int speaker */
8677         /*{0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},*/
8678
8679         /* enable unsolicited event */
8680         /*
8681         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8682         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8683         */
8684
8685         { } /* end */
8686 };
8687
8688 static struct hda_verb alc883_clevo_m720_verbs[] = {
8689         /* HP */
8690         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8691         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8692         /* Int speaker */
8693         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
8694         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8695
8696         /* enable unsolicited event */
8697         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8698         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
8699
8700         { } /* end */
8701 };
8702
8703 static struct hda_verb alc883_2ch_fujitsu_pi2515_verbs[] = {
8704         /* HP */
8705         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
8706         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8707         /* Subwoofer */
8708         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
8709         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8710
8711         /* enable unsolicited event */
8712         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8713
8714         { } /* end */
8715 };
8716
8717 static struct hda_verb alc883_targa_verbs[] = {
8718         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8719         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8720
8721         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8722         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8723
8724 /* Connect Line-Out side jack (SPDIF) to Side */
8725         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8726         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8727         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
8728 /* Connect Mic jack to CLFE */
8729         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8730         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8731         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},
8732 /* Connect Line-in jack to Surround */
8733         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8734         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8735         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
8736 /* Connect HP out jack to Front */
8737         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8738         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
8739         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8740
8741         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8742
8743         { } /* end */
8744 };
8745
8746 static struct hda_verb alc883_lenovo_101e_verbs[] = {
8747         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8748         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT|AC_USRSP_EN},
8749         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT|AC_USRSP_EN},
8750         { } /* end */
8751 };
8752
8753 static struct hda_verb alc883_lenovo_nb0763_verbs[] = {
8754         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8755         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8756         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8757         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8758         { } /* end */
8759 };
8760
8761 static struct hda_verb alc888_lenovo_ms7195_verbs[] = {
8762         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8763         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8764         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8765         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_FRONT_EVENT | AC_USRSP_EN},
8766         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT    | AC_USRSP_EN},
8767         { } /* end */
8768 };
8769
8770 static struct hda_verb alc883_haier_w66_verbs[] = {
8771         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8772         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8773
8774         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8775
8776         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
8777         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8778         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8779         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8780         { } /* end */
8781 };
8782
8783 static struct hda_verb alc888_lenovo_sky_verbs[] = {
8784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8785         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8786         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8787         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8788         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8789         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
8790         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x00},
8791         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8792         { } /* end */
8793 };
8794
8795 static struct hda_verb alc888_6st_dell_verbs[] = {
8796         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8797         { }
8798 };
8799
8800 static struct hda_verb alc883_vaiott_verbs[] = {
8801         /* HP */
8802         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
8803         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8804
8805         /* enable unsolicited event */
8806         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8807
8808         { } /* end */
8809 };
8810
8811 static void alc888_3st_hp_setup(struct hda_codec *codec)
8812 {
8813         struct alc_spec *spec = codec->spec;
8814
8815         spec->autocfg.hp_pins[0] = 0x1b;
8816         spec->autocfg.speaker_pins[0] = 0x14;
8817         spec->autocfg.speaker_pins[1] = 0x16;
8818         spec->autocfg.speaker_pins[2] = 0x18;
8819 }
8820
8821 static struct hda_verb alc888_3st_hp_verbs[] = {
8822         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Front: output 0 (0x0c) */
8823         {0x16, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Rear : output 1 (0x0d) */
8824         {0x18, AC_VERB_SET_CONNECT_SEL, 0x02},  /* CLFE : output 2 (0x0e) */
8825         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8826         { } /* end */
8827 };
8828
8829 /*
8830  * 2ch mode
8831  */
8832 static struct hda_verb alc888_3st_hp_2ch_init[] = {
8833         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8834         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8835         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
8836         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8837         { } /* end */
8838 };
8839
8840 /*
8841  * 4ch mode
8842  */
8843 static struct hda_verb alc888_3st_hp_4ch_init[] = {
8844         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
8845         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
8846         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8847         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8848         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8849         { } /* end */
8850 };
8851
8852 /*
8853  * 6ch mode
8854  */
8855 static struct hda_verb alc888_3st_hp_6ch_init[] = {
8856         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8857         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8858         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
8859         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
8860         { 0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
8861         { 0x16, AC_VERB_SET_CONNECT_SEL, 0x01 },
8862         { } /* end */
8863 };
8864
8865 static struct hda_channel_mode alc888_3st_hp_modes[3] = {
8866         { 2, alc888_3st_hp_2ch_init },
8867         { 4, alc888_3st_hp_4ch_init },
8868         { 6, alc888_3st_hp_6ch_init },
8869 };
8870
8871 /* toggle front-jack and RCA according to the hp-jack state */
8872 static void alc888_lenovo_ms7195_front_automute(struct hda_codec *codec)
8873 {
8874         unsigned int present = snd_hda_jack_detect(codec, 0x1b);
8875
8876         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8877                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8878         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8879                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8880 }
8881
8882 /* toggle RCA according to the front-jack state */
8883 static void alc888_lenovo_ms7195_rca_automute(struct hda_codec *codec)
8884 {
8885         unsigned int present = snd_hda_jack_detect(codec, 0x14);
8886
8887         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8888                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8889 }
8890
8891 static void alc883_lenovo_ms7195_unsol_event(struct hda_codec *codec,
8892                                              unsigned int res)
8893 {
8894         if ((res >> 26) == ALC880_HP_EVENT)
8895                 alc888_lenovo_ms7195_front_automute(codec);
8896         if ((res >> 26) == ALC880_FRONT_EVENT)
8897                 alc888_lenovo_ms7195_rca_automute(codec);
8898 }
8899
8900 static struct hda_verb alc883_medion_md2_verbs[] = {
8901         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
8902         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
8903
8904         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
8905
8906         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
8907         { } /* end */
8908 };
8909
8910 /* toggle speaker-output according to the hp-jack state */
8911 static void alc883_medion_md2_setup(struct hda_codec *codec)
8912 {
8913         struct alc_spec *spec = codec->spec;
8914
8915         spec->autocfg.hp_pins[0] = 0x14;
8916         spec->autocfg.speaker_pins[0] = 0x15;
8917 }
8918
8919 /* toggle speaker-output according to the hp-jack state */
8920 #define alc883_targa_init_hook          alc882_targa_init_hook
8921 #define alc883_targa_unsol_event        alc882_targa_unsol_event
8922
8923 static void alc883_clevo_m720_mic_automute(struct hda_codec *codec)
8924 {
8925         unsigned int present;
8926
8927         present = snd_hda_jack_detect(codec, 0x18);
8928         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
8929                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
8930 }
8931
8932 static void alc883_clevo_m720_setup(struct hda_codec *codec)
8933 {
8934         struct alc_spec *spec = codec->spec;
8935
8936         spec->autocfg.hp_pins[0] = 0x15;
8937         spec->autocfg.speaker_pins[0] = 0x14;
8938 }
8939
8940 static void alc883_clevo_m720_init_hook(struct hda_codec *codec)
8941 {
8942         alc_automute_amp(codec);
8943         alc883_clevo_m720_mic_automute(codec);
8944 }
8945
8946 static void alc883_clevo_m720_unsol_event(struct hda_codec *codec,
8947                                            unsigned int res)
8948 {
8949         switch (res >> 26) {
8950         case ALC880_MIC_EVENT:
8951                 alc883_clevo_m720_mic_automute(codec);
8952                 break;
8953         default:
8954                 alc_automute_amp_unsol_event(codec, res);
8955                 break;
8956         }
8957 }
8958
8959 /* toggle speaker-output according to the hp-jack state */
8960 static void alc883_2ch_fujitsu_pi2515_setup(struct hda_codec *codec)
8961 {
8962         struct alc_spec *spec = codec->spec;
8963
8964         spec->autocfg.hp_pins[0] = 0x14;
8965         spec->autocfg.speaker_pins[0] = 0x15;
8966 }
8967
8968 static void alc883_haier_w66_setup(struct hda_codec *codec)
8969 {
8970         struct alc_spec *spec = codec->spec;
8971
8972         spec->autocfg.hp_pins[0] = 0x1b;
8973         spec->autocfg.speaker_pins[0] = 0x14;
8974 }
8975
8976 static void alc883_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
8977 {
8978         int bits = snd_hda_jack_detect(codec, 0x14) ? HDA_AMP_MUTE : 0;
8979
8980         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8981                                  HDA_AMP_MUTE, bits);
8982 }
8983
8984 static void alc883_lenovo_101e_all_automute(struct hda_codec *codec)
8985 {
8986         int bits = snd_hda_jack_detect(codec, 0x1b) ? HDA_AMP_MUTE : 0;
8987
8988         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
8989                                  HDA_AMP_MUTE, bits);
8990         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
8991                                  HDA_AMP_MUTE, bits);
8992 }
8993
8994 static void alc883_lenovo_101e_unsol_event(struct hda_codec *codec,
8995                                            unsigned int res)
8996 {
8997         if ((res >> 26) == ALC880_HP_EVENT)
8998                 alc883_lenovo_101e_all_automute(codec);
8999         if ((res >> 26) == ALC880_FRONT_EVENT)
9000                 alc883_lenovo_101e_ispeaker_automute(codec);
9001 }
9002
9003 /* toggle speaker-output according to the hp-jack state */
9004 static void alc883_acer_aspire_setup(struct hda_codec *codec)
9005 {
9006         struct alc_spec *spec = codec->spec;
9007
9008         spec->autocfg.hp_pins[0] = 0x14;
9009         spec->autocfg.speaker_pins[0] = 0x15;
9010         spec->autocfg.speaker_pins[1] = 0x16;
9011 }
9012
9013 static struct hda_verb alc883_acer_eapd_verbs[] = {
9014         /* HP Pin: output 0 (0x0c) */
9015         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9016         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
9017         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
9018         /* Front Pin: output 0 (0x0c) */
9019         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9020         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9021         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9022         {0x16, AC_VERB_SET_CONNECT_SEL, 0x00},
9023         /* eanable EAPD on medion laptop */
9024         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
9025         {0x20, AC_VERB_SET_PROC_COEF, 0x3050},
9026         /* enable unsolicited event */
9027         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9028         { }
9029 };
9030
9031 static struct hda_verb alc888_acer_aspire_7730G_verbs[] = {
9032         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
9033         {0x17, AC_VERB_SET_CONNECT_SEL, 0x02},
9034         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9035         { } /* end */
9036 };
9037
9038 static void alc888_6st_dell_setup(struct hda_codec *codec)
9039 {
9040         struct alc_spec *spec = codec->spec;
9041
9042         spec->autocfg.hp_pins[0] = 0x1b;
9043         spec->autocfg.speaker_pins[0] = 0x14;
9044         spec->autocfg.speaker_pins[1] = 0x15;
9045         spec->autocfg.speaker_pins[2] = 0x16;
9046         spec->autocfg.speaker_pins[3] = 0x17;
9047 }
9048
9049 static void alc888_lenovo_sky_setup(struct hda_codec *codec)
9050 {
9051         struct alc_spec *spec = codec->spec;
9052
9053         spec->autocfg.hp_pins[0] = 0x1b;
9054         spec->autocfg.speaker_pins[0] = 0x14;
9055         spec->autocfg.speaker_pins[1] = 0x15;
9056         spec->autocfg.speaker_pins[2] = 0x16;
9057         spec->autocfg.speaker_pins[3] = 0x17;
9058         spec->autocfg.speaker_pins[4] = 0x1a;
9059 }
9060
9061 static void alc883_vaiott_setup(struct hda_codec *codec)
9062 {
9063         struct alc_spec *spec = codec->spec;
9064
9065         spec->autocfg.hp_pins[0] = 0x15;
9066         spec->autocfg.speaker_pins[0] = 0x14;
9067         spec->autocfg.speaker_pins[1] = 0x17;
9068 }
9069
9070 static struct hda_verb alc888_asus_m90v_verbs[] = {
9071         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9072         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9073         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
9074         /* enable unsolicited event */
9075         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9076         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
9077         { } /* end */
9078 };
9079
9080 static void alc883_mode2_setup(struct hda_codec *codec)
9081 {
9082         struct alc_spec *spec = codec->spec;
9083
9084         spec->autocfg.hp_pins[0] = 0x1b;
9085         spec->autocfg.speaker_pins[0] = 0x14;
9086         spec->autocfg.speaker_pins[1] = 0x15;
9087         spec->autocfg.speaker_pins[2] = 0x16;
9088         spec->ext_mic.pin = 0x18;
9089         spec->int_mic.pin = 0x19;
9090         spec->ext_mic.mux_idx = 0;
9091         spec->int_mic.mux_idx = 1;
9092         spec->auto_mic = 1;
9093 }
9094
9095 static struct hda_verb alc888_asus_eee1601_verbs[] = {
9096         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
9097         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
9098         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
9099         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
9100         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
9101         {0x20, AC_VERB_SET_COEF_INDEX, 0x0b},
9102         {0x20, AC_VERB_SET_PROC_COEF,  0x0838},
9103         /* enable unsolicited event */
9104         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9105         { } /* end */
9106 };
9107
9108 static void alc883_eee1601_inithook(struct hda_codec *codec)
9109 {
9110         struct alc_spec *spec = codec->spec;
9111
9112         spec->autocfg.hp_pins[0] = 0x14;
9113         spec->autocfg.speaker_pins[0] = 0x1b;
9114         alc_automute_pin(codec);
9115 }
9116
9117 static struct hda_verb alc889A_mb31_verbs[] = {
9118         /* Init rear pin (used as headphone output) */
9119         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc4},    /* Apple Headphones */
9120         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},           /* Connect to front */
9121         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
9122         /* Init line pin (used as output in 4ch and 6ch mode) */
9123         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x02},           /* Connect to CLFE */
9124         /* Init line 2 pin (used as headphone out by default) */
9125         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},  /* Use as input */
9126         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE}, /* Mute output */
9127         { } /* end */
9128 };
9129
9130 /* Mute speakers according to the headphone jack state */
9131 static void alc889A_mb31_automute(struct hda_codec *codec)
9132 {
9133         unsigned int present;
9134
9135         /* Mute only in 2ch or 4ch mode */
9136         if (snd_hda_codec_read(codec, 0x15, 0, AC_VERB_GET_CONNECT_SEL, 0)
9137             == 0x00) {
9138                 present = snd_hda_jack_detect(codec, 0x15);
9139                 snd_hda_codec_amp_stereo(codec, 0x14,  HDA_OUTPUT, 0,
9140                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9141                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
9142                         HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
9143         }
9144 }
9145
9146 static void alc889A_mb31_unsol_event(struct hda_codec *codec, unsigned int res)
9147 {
9148         if ((res >> 26) == ALC880_HP_EVENT)
9149                 alc889A_mb31_automute(codec);
9150 }
9151
9152
9153 #ifdef CONFIG_SND_HDA_POWER_SAVE
9154 #define alc882_loopbacks        alc880_loopbacks
9155 #endif
9156
9157 /* pcm configuration: identical with ALC880 */
9158 #define alc882_pcm_analog_playback      alc880_pcm_analog_playback
9159 #define alc882_pcm_analog_capture       alc880_pcm_analog_capture
9160 #define alc882_pcm_digital_playback     alc880_pcm_digital_playback
9161 #define alc882_pcm_digital_capture      alc880_pcm_digital_capture
9162
9163 static hda_nid_t alc883_slave_dig_outs[] = {
9164         ALC1200_DIGOUT_NID, 0,
9165 };
9166
9167 static hda_nid_t alc1200_slave_dig_outs[] = {
9168         ALC883_DIGOUT_NID, 0,
9169 };
9170
9171 /*
9172  * configuration and preset
9173  */
9174 static const char *alc882_models[ALC882_MODEL_LAST] = {
9175         [ALC882_3ST_DIG]        = "3stack-dig",
9176         [ALC882_6ST_DIG]        = "6stack-dig",
9177         [ALC882_ARIMA]          = "arima",
9178         [ALC882_W2JC]           = "w2jc",
9179         [ALC882_TARGA]          = "targa",
9180         [ALC882_ASUS_A7J]       = "asus-a7j",
9181         [ALC882_ASUS_A7M]       = "asus-a7m",
9182         [ALC885_MACPRO]         = "macpro",
9183         [ALC885_MB5]            = "mb5",
9184         [ALC885_MACMINI3]       = "macmini3",
9185         [ALC885_MBA21]          = "mba21",
9186         [ALC885_MBP3]           = "mbp3",
9187         [ALC885_IMAC24]         = "imac24",
9188         [ALC885_IMAC91]         = "imac91",
9189         [ALC883_3ST_2ch_DIG]    = "3stack-2ch-dig",
9190         [ALC883_3ST_6ch_DIG]    = "3stack-6ch-dig",
9191         [ALC883_3ST_6ch]        = "3stack-6ch",
9192         [ALC883_6ST_DIG]        = "alc883-6stack-dig",
9193         [ALC883_TARGA_DIG]      = "targa-dig",
9194         [ALC883_TARGA_2ch_DIG]  = "targa-2ch-dig",
9195         [ALC883_TARGA_8ch_DIG]  = "targa-8ch-dig",
9196         [ALC883_ACER]           = "acer",
9197         [ALC883_ACER_ASPIRE]    = "acer-aspire",
9198         [ALC888_ACER_ASPIRE_4930G]      = "acer-aspire-4930g",
9199         [ALC888_ACER_ASPIRE_6530G]      = "acer-aspire-6530g",
9200         [ALC888_ACER_ASPIRE_8930G]      = "acer-aspire-8930g",
9201         [ALC888_ACER_ASPIRE_7730G]      = "acer-aspire-7730g",
9202         [ALC883_MEDION]         = "medion",
9203         [ALC883_MEDION_MD2]     = "medion-md2",
9204         [ALC883_MEDION_WIM2160] = "medion-wim2160",
9205         [ALC883_LAPTOP_EAPD]    = "laptop-eapd",
9206         [ALC883_LENOVO_101E_2ch] = "lenovo-101e",
9207         [ALC883_LENOVO_NB0763]  = "lenovo-nb0763",
9208         [ALC888_LENOVO_MS7195_DIG] = "lenovo-ms7195-dig",
9209         [ALC888_LENOVO_SKY] = "lenovo-sky",
9210         [ALC883_HAIER_W66]      = "haier-w66",
9211         [ALC888_3ST_HP]         = "3stack-hp",
9212         [ALC888_6ST_DELL]       = "6stack-dell",
9213         [ALC883_MITAC]          = "mitac",
9214         [ALC883_CLEVO_M540R]    = "clevo-m540r",
9215         [ALC883_CLEVO_M720]     = "clevo-m720",
9216         [ALC883_FUJITSU_PI2515] = "fujitsu-pi2515",
9217         [ALC888_FUJITSU_XA3530] = "fujitsu-xa3530",
9218         [ALC883_3ST_6ch_INTEL]  = "3stack-6ch-intel",
9219         [ALC889A_INTEL]         = "intel-alc889a",
9220         [ALC889_INTEL]          = "intel-x58",
9221         [ALC1200_ASUS_P5Q]      = "asus-p5q",
9222         [ALC889A_MB31]          = "mb31",
9223         [ALC883_SONY_VAIO_TT]   = "sony-vaio-tt",
9224         [ALC882_AUTO]           = "auto",
9225 };
9226
9227 static struct snd_pci_quirk alc882_cfg_tbl[] = {
9228         SND_PCI_QUIRK(0x1019, 0x6668, "ECS", ALC882_6ST_DIG),
9229
9230         SND_PCI_QUIRK(0x1025, 0x006c, "Acer Aspire 9810", ALC883_ACER_ASPIRE),
9231         SND_PCI_QUIRK(0x1025, 0x0090, "Acer Aspire", ALC883_ACER_ASPIRE),
9232         SND_PCI_QUIRK(0x1025, 0x010a, "Acer Ferrari 5000", ALC883_ACER_ASPIRE),
9233         SND_PCI_QUIRK(0x1025, 0x0110, "Acer Aspire", ALC883_ACER_ASPIRE),
9234         SND_PCI_QUIRK(0x1025, 0x0112, "Acer Aspire 9303", ALC883_ACER_ASPIRE),
9235         SND_PCI_QUIRK(0x1025, 0x0121, "Acer Aspire 5920G", ALC883_ACER_ASPIRE),
9236         SND_PCI_QUIRK(0x1025, 0x013e, "Acer Aspire 4930G",
9237                 ALC888_ACER_ASPIRE_4930G),
9238         SND_PCI_QUIRK(0x1025, 0x013f, "Acer Aspire 5930G",
9239                 ALC888_ACER_ASPIRE_4930G),
9240         SND_PCI_QUIRK(0x1025, 0x0145, "Acer Aspire 8930G",
9241                 ALC888_ACER_ASPIRE_8930G),
9242         SND_PCI_QUIRK(0x1025, 0x0146, "Acer Aspire 6935G",
9243                 ALC888_ACER_ASPIRE_8930G),
9244         SND_PCI_QUIRK(0x1025, 0x0157, "Acer X3200", ALC882_AUTO),
9245         SND_PCI_QUIRK(0x1025, 0x0158, "Acer AX1700-U3700A", ALC882_AUTO),
9246         SND_PCI_QUIRK(0x1025, 0x015e, "Acer Aspire 6930G",
9247                 ALC888_ACER_ASPIRE_6530G),
9248         SND_PCI_QUIRK(0x1025, 0x0166, "Acer Aspire 6530G",
9249                 ALC888_ACER_ASPIRE_6530G),
9250         SND_PCI_QUIRK(0x1025, 0x0142, "Acer Aspire 7730G",
9251                 ALC888_ACER_ASPIRE_7730G),
9252         /* default Acer -- disabled as it causes more problems.
9253          *    model=auto should work fine now
9254          */
9255         /* SND_PCI_QUIRK_VENDOR(0x1025, "Acer laptop", ALC883_ACER), */
9256
9257         SND_PCI_QUIRK(0x1028, 0x020d, "Dell Inspiron 530", ALC888_6ST_DELL),
9258
9259         SND_PCI_QUIRK(0x103c, 0x2a3d, "HP Pavillion", ALC883_6ST_DIG),
9260         SND_PCI_QUIRK(0x103c, 0x2a4f, "HP Samba", ALC888_3ST_HP),
9261         SND_PCI_QUIRK(0x103c, 0x2a60, "HP Lucknow", ALC888_3ST_HP),
9262         SND_PCI_QUIRK(0x103c, 0x2a61, "HP Nettle", ALC883_6ST_DIG),
9263         SND_PCI_QUIRK(0x103c, 0x2a66, "HP Acacia", ALC888_3ST_HP),
9264         SND_PCI_QUIRK(0x103c, 0x2a72, "HP Educ.ar", ALC888_3ST_HP),
9265
9266         SND_PCI_QUIRK(0x1043, 0x060d, "Asus A7J", ALC882_ASUS_A7J),
9267         SND_PCI_QUIRK(0x1043, 0x1243, "Asus A7J", ALC882_ASUS_A7J),
9268         SND_PCI_QUIRK(0x1043, 0x13c2, "Asus A7M", ALC882_ASUS_A7M),
9269         SND_PCI_QUIRK(0x1043, 0x1873, "Asus M90V", ALC888_ASUS_M90V),
9270         SND_PCI_QUIRK(0x1043, 0x1971, "Asus W2JC", ALC882_W2JC),
9271         SND_PCI_QUIRK(0x1043, 0x817f, "Asus P5LD2", ALC882_6ST_DIG),
9272         SND_PCI_QUIRK(0x1043, 0x81d8, "Asus P5WD", ALC882_6ST_DIG),
9273         SND_PCI_QUIRK(0x1043, 0x8249, "Asus M2A-VM HDMI", ALC883_3ST_6ch_DIG),
9274         SND_PCI_QUIRK(0x1043, 0x8284, "Asus Z37E", ALC883_6ST_DIG),
9275         SND_PCI_QUIRK(0x1043, 0x82fe, "Asus P5Q-EM HDMI", ALC1200_ASUS_P5Q),
9276         SND_PCI_QUIRK(0x1043, 0x835f, "Asus Eee 1601", ALC888_ASUS_EEE1601),
9277
9278         SND_PCI_QUIRK(0x104d, 0x9047, "Sony Vaio TT", ALC883_SONY_VAIO_TT),
9279         SND_PCI_QUIRK(0x105b, 0x0ce8, "Foxconn P35AX-S", ALC883_6ST_DIG),
9280         SND_PCI_QUIRK(0x105b, 0x6668, "Foxconn", ALC882_6ST_DIG),
9281         SND_PCI_QUIRK(0x1071, 0x8227, "Mitac 82801H", ALC883_MITAC),
9282         SND_PCI_QUIRK(0x1071, 0x8253, "Mitac 8252d", ALC883_MITAC),
9283         SND_PCI_QUIRK(0x1071, 0x8258, "Evesham Voyaeger", ALC883_LAPTOP_EAPD),
9284         SND_PCI_QUIRK(0x10f1, 0x2350, "TYAN-S2350", ALC888_6ST_DELL),
9285         SND_PCI_QUIRK(0x108e, 0x534d, NULL, ALC883_3ST_6ch),
9286         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte P35 DS3R", ALC882_6ST_DIG),
9287
9288         SND_PCI_QUIRK(0x1462, 0x0349, "MSI", ALC883_TARGA_2ch_DIG),
9289         SND_PCI_QUIRK(0x1462, 0x040d, "MSI", ALC883_TARGA_2ch_DIG),
9290         SND_PCI_QUIRK(0x1462, 0x0579, "MSI", ALC883_TARGA_2ch_DIG),
9291         SND_PCI_QUIRK(0x1462, 0x28fb, "Targa T8", ALC882_TARGA), /* MSI-1049 T8  */
9292         SND_PCI_QUIRK(0x1462, 0x2fb3, "MSI", ALC882_AUTO),
9293         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC882_6ST_DIG),
9294         SND_PCI_QUIRK(0x1462, 0x3729, "MSI S420", ALC883_TARGA_DIG),
9295         SND_PCI_QUIRK(0x1462, 0x3783, "NEC S970", ALC883_TARGA_DIG),
9296         SND_PCI_QUIRK(0x1462, 0x3b7f, "MSI", ALC883_TARGA_2ch_DIG),
9297         SND_PCI_QUIRK(0x1462, 0x3ef9, "MSI", ALC883_TARGA_DIG),
9298         SND_PCI_QUIRK(0x1462, 0x3fc1, "MSI", ALC883_TARGA_DIG),
9299         SND_PCI_QUIRK(0x1462, 0x3fc3, "MSI", ALC883_TARGA_DIG),
9300         SND_PCI_QUIRK(0x1462, 0x3fcc, "MSI", ALC883_TARGA_DIG),
9301         SND_PCI_QUIRK(0x1462, 0x3fdf, "MSI", ALC883_TARGA_DIG),
9302         SND_PCI_QUIRK(0x1462, 0x42cd, "MSI", ALC883_TARGA_DIG),
9303         SND_PCI_QUIRK(0x1462, 0x4314, "MSI", ALC883_TARGA_DIG),
9304         SND_PCI_QUIRK(0x1462, 0x4319, "MSI", ALC883_TARGA_DIG),
9305         SND_PCI_QUIRK(0x1462, 0x4324, "MSI", ALC883_TARGA_DIG),
9306         SND_PCI_QUIRK(0x1462, 0x4570, "MSI Wind Top AE2220", ALC883_TARGA_DIG),
9307         SND_PCI_QUIRK(0x1462, 0x6510, "MSI GX620", ALC883_TARGA_8ch_DIG),
9308         SND_PCI_QUIRK(0x1462, 0x6668, "MSI", ALC883_6ST_DIG),
9309         SND_PCI_QUIRK(0x1462, 0x7187, "MSI", ALC883_6ST_DIG),
9310         SND_PCI_QUIRK(0x1462, 0x7250, "MSI", ALC883_6ST_DIG),
9311         SND_PCI_QUIRK(0x1462, 0x7260, "MSI 7260", ALC883_TARGA_DIG),
9312         SND_PCI_QUIRK(0x1462, 0x7267, "MSI", ALC883_3ST_6ch_DIG),
9313         SND_PCI_QUIRK(0x1462, 0x7280, "MSI", ALC883_6ST_DIG),
9314         SND_PCI_QUIRK(0x1462, 0x7327, "MSI", ALC883_6ST_DIG),
9315         SND_PCI_QUIRK(0x1462, 0x7350, "MSI", ALC883_6ST_DIG),
9316         SND_PCI_QUIRK(0x1462, 0x7437, "MSI NetOn AP1900", ALC883_TARGA_DIG),
9317         SND_PCI_QUIRK(0x1462, 0xa422, "MSI", ALC883_TARGA_2ch_DIG),
9318         SND_PCI_QUIRK(0x1462, 0xaa08, "MSI", ALC883_TARGA_2ch_DIG),
9319
9320         SND_PCI_QUIRK(0x147b, 0x1083, "Abit IP35-PRO", ALC883_6ST_DIG),
9321         SND_PCI_QUIRK(0x1558, 0x0721, "Clevo laptop M720R", ALC883_CLEVO_M720),
9322         SND_PCI_QUIRK(0x1558, 0x0722, "Clevo laptop M720SR", ALC883_CLEVO_M720),
9323         SND_PCI_QUIRK(0x1558, 0x5409, "Clevo laptop M540R", ALC883_CLEVO_M540R),
9324         SND_PCI_QUIRK_VENDOR(0x1558, "Clevo laptop", ALC883_LAPTOP_EAPD),
9325         SND_PCI_QUIRK(0x15d9, 0x8780, "Supermicro PDSBA", ALC883_3ST_6ch),
9326         /* SND_PCI_QUIRK(0x161f, 0x2054, "Arima W820", ALC882_ARIMA), */
9327         SND_PCI_QUIRK(0x161f, 0x2054, "Medion laptop", ALC883_MEDION),
9328         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1100, "FSC AMILO Xi/Pi25xx",
9329                       ALC883_FUJITSU_PI2515),
9330         SND_PCI_QUIRK_MASK(0x1734, 0xfff0, 0x1130, "Fujitsu AMILO Xa35xx",
9331                 ALC888_FUJITSU_XA3530),
9332         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo 101e", ALC883_LENOVO_101E_2ch),
9333         SND_PCI_QUIRK(0x17aa, 0x2085, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9334         SND_PCI_QUIRK(0x17aa, 0x3bfc, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9335         SND_PCI_QUIRK(0x17aa, 0x3bfd, "Lenovo NB0763", ALC883_LENOVO_NB0763),
9336         SND_PCI_QUIRK(0x17aa, 0x101d, "Lenovo Sky", ALC888_LENOVO_SKY),
9337         SND_PCI_QUIRK(0x17c0, 0x4071, "MEDION MD2", ALC883_MEDION_MD2),
9338         SND_PCI_QUIRK(0x17c0, 0x4085, "MEDION MD96630", ALC888_LENOVO_MS7195_DIG),
9339         SND_PCI_QUIRK(0x17f2, 0x5000, "Albatron KI690-AM2", ALC883_6ST_DIG),
9340         SND_PCI_QUIRK(0x1991, 0x5625, "Haier W66", ALC883_HAIER_W66),
9341
9342         SND_PCI_QUIRK(0x8086, 0x0001, "DG33BUC", ALC883_3ST_6ch_INTEL),
9343         SND_PCI_QUIRK(0x8086, 0x0002, "DG33FBC", ALC883_3ST_6ch_INTEL),
9344         SND_PCI_QUIRK(0x8086, 0x2503, "82801H", ALC883_MITAC),
9345         SND_PCI_QUIRK(0x8086, 0x0022, "DX58SO", ALC889_INTEL),
9346         SND_PCI_QUIRK(0x8086, 0x0021, "Intel IbexPeak", ALC889A_INTEL),
9347         SND_PCI_QUIRK(0x8086, 0x3b56, "Intel IbexPeak", ALC889A_INTEL),
9348         SND_PCI_QUIRK(0x8086, 0xd601, "D102GGC", ALC882_6ST_DIG),
9349
9350         {}
9351 };
9352
9353 /* codec SSID table for Intel Mac */
9354 static struct snd_pci_quirk alc882_ssid_cfg_tbl[] = {
9355         SND_PCI_QUIRK(0x106b, 0x00a0, "MacBookPro 3,1", ALC885_MBP3),
9356         SND_PCI_QUIRK(0x106b, 0x00a1, "Macbook", ALC885_MBP3),
9357         SND_PCI_QUIRK(0x106b, 0x00a4, "MacbookPro 4,1", ALC885_MBP3),
9358         SND_PCI_QUIRK(0x106b, 0x0c00, "Mac Pro", ALC885_MACPRO),
9359         SND_PCI_QUIRK(0x106b, 0x1000, "iMac 24", ALC885_IMAC24),
9360         SND_PCI_QUIRK(0x106b, 0x2800, "AppleTV", ALC885_IMAC24),
9361         SND_PCI_QUIRK(0x106b, 0x2c00, "MacbookPro rev3", ALC885_MBP3),
9362         SND_PCI_QUIRK(0x106b, 0x3600, "Macbook 3,1", ALC889A_MB31),
9363         SND_PCI_QUIRK(0x106b, 0x3800, "MacbookPro 4,1", ALC885_MBP3),
9364         SND_PCI_QUIRK(0x106b, 0x3e00, "iMac 24 Aluminum", ALC885_IMAC24),
9365         SND_PCI_QUIRK(0x106b, 0x4900, "iMac 9,1 Aluminum", ALC885_IMAC91),
9366         SND_PCI_QUIRK(0x106b, 0x3f00, "Macbook 5,1", ALC885_MB5),
9367         /* FIXME: HP jack sense seems not working for MBP 5,1 or 5,2,
9368          * so apparently no perfect solution yet
9369          */
9370         SND_PCI_QUIRK(0x106b, 0x4000, "MacbookPro 5,1", ALC885_MB5),
9371         SND_PCI_QUIRK(0x106b, 0x4600, "MacbookPro 5,2", ALC885_MB5),
9372         SND_PCI_QUIRK(0x106b, 0x4100, "Macmini 3,1", ALC885_MACMINI3),
9373         {} /* terminator */
9374 };
9375
9376 static struct alc_config_preset alc882_presets[] = {
9377         [ALC882_3ST_DIG] = {
9378                 .mixers = { alc882_base_mixer },
9379                 .init_verbs = { alc882_base_init_verbs,
9380                                 alc882_adc1_init_verbs },
9381                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9382                 .dac_nids = alc882_dac_nids,
9383                 .dig_out_nid = ALC882_DIGOUT_NID,
9384                 .dig_in_nid = ALC882_DIGIN_NID,
9385                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9386                 .channel_mode = alc882_ch_modes,
9387                 .need_dac_fix = 1,
9388                 .input_mux = &alc882_capture_source,
9389         },
9390         [ALC882_6ST_DIG] = {
9391                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9392                 .init_verbs = { alc882_base_init_verbs,
9393                                 alc882_adc1_init_verbs },
9394                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9395                 .dac_nids = alc882_dac_nids,
9396                 .dig_out_nid = ALC882_DIGOUT_NID,
9397                 .dig_in_nid = ALC882_DIGIN_NID,
9398                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9399                 .channel_mode = alc882_sixstack_modes,
9400                 .input_mux = &alc882_capture_source,
9401         },
9402         [ALC882_ARIMA] = {
9403                 .mixers = { alc882_base_mixer, alc882_chmode_mixer },
9404                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9405                                 alc882_eapd_verbs },
9406                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9407                 .dac_nids = alc882_dac_nids,
9408                 .num_channel_mode = ARRAY_SIZE(alc882_sixstack_modes),
9409                 .channel_mode = alc882_sixstack_modes,
9410                 .input_mux = &alc882_capture_source,
9411         },
9412         [ALC882_W2JC] = {
9413                 .mixers = { alc882_w2jc_mixer, alc882_chmode_mixer },
9414                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9415                                 alc882_eapd_verbs, alc880_gpio1_init_verbs },
9416                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9417                 .dac_nids = alc882_dac_nids,
9418                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9419                 .channel_mode = alc880_threestack_modes,
9420                 .need_dac_fix = 1,
9421                 .input_mux = &alc882_capture_source,
9422                 .dig_out_nid = ALC882_DIGOUT_NID,
9423         },
9424            [ALC885_MBA21] = {
9425                         .mixers = { alc885_mba21_mixer },
9426                         .init_verbs = { alc885_mba21_init_verbs, alc880_gpio1_init_verbs },
9427                         .num_dacs = 2,
9428                         .dac_nids = alc882_dac_nids,
9429                         .channel_mode = alc885_mba21_ch_modes,
9430                         .num_channel_mode = ARRAY_SIZE(alc885_mba21_ch_modes),
9431                         .input_mux = &alc882_capture_source,
9432                         .unsol_event = alc_automute_amp_unsol_event,
9433                         .setup = alc885_mba21_setup,
9434                         .init_hook = alc_automute_amp,
9435        },
9436         [ALC885_MBP3] = {
9437                 .mixers = { alc885_mbp3_mixer, alc882_chmode_mixer },
9438                 .init_verbs = { alc885_mbp3_init_verbs,
9439                                 alc880_gpio1_init_verbs },
9440                 .num_dacs = 2,
9441                 .dac_nids = alc882_dac_nids,
9442                 .hp_nid = 0x04,
9443                 .channel_mode = alc885_mbp_4ch_modes,
9444                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9445                 .input_mux = &alc882_capture_source,
9446                 .dig_out_nid = ALC882_DIGOUT_NID,
9447                 .dig_in_nid = ALC882_DIGIN_NID,
9448                 .unsol_event = alc_automute_amp_unsol_event,
9449                 .setup = alc885_mbp3_setup,
9450                 .init_hook = alc_automute_amp,
9451         },
9452         [ALC885_MB5] = {
9453                 .mixers = { alc885_mb5_mixer, alc882_chmode_mixer },
9454                 .init_verbs = { alc885_mb5_init_verbs,
9455                                 alc880_gpio1_init_verbs },
9456                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9457                 .dac_nids = alc882_dac_nids,
9458                 .channel_mode = alc885_mb5_6ch_modes,
9459                 .num_channel_mode = ARRAY_SIZE(alc885_mb5_6ch_modes),
9460                 .input_mux = &mb5_capture_source,
9461                 .dig_out_nid = ALC882_DIGOUT_NID,
9462                 .dig_in_nid = ALC882_DIGIN_NID,
9463                 .unsol_event = alc_automute_amp_unsol_event,
9464                 .setup = alc885_mb5_setup,
9465                 .init_hook = alc_automute_amp,
9466         },
9467         [ALC885_MACMINI3] = {
9468                 .mixers = { alc885_macmini3_mixer, alc882_chmode_mixer },
9469                 .init_verbs = { alc885_macmini3_init_verbs,
9470                                 alc880_gpio1_init_verbs },
9471                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9472                 .dac_nids = alc882_dac_nids,
9473                 .channel_mode = alc885_macmini3_6ch_modes,
9474                 .num_channel_mode = ARRAY_SIZE(alc885_macmini3_6ch_modes),
9475                 .input_mux = &macmini3_capture_source,
9476                 .dig_out_nid = ALC882_DIGOUT_NID,
9477                 .dig_in_nid = ALC882_DIGIN_NID,
9478                 .unsol_event = alc_automute_amp_unsol_event,
9479                 .setup = alc885_macmini3_setup,
9480                 .init_hook = alc_automute_amp,
9481         },
9482         [ALC885_MACPRO] = {
9483                 .mixers = { alc882_macpro_mixer },
9484                 .init_verbs = { alc882_macpro_init_verbs },
9485                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9486                 .dac_nids = alc882_dac_nids,
9487                 .dig_out_nid = ALC882_DIGOUT_NID,
9488                 .dig_in_nid = ALC882_DIGIN_NID,
9489                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9490                 .channel_mode = alc882_ch_modes,
9491                 .input_mux = &alc882_capture_source,
9492                 .init_hook = alc885_macpro_init_hook,
9493         },
9494         [ALC885_IMAC24] = {
9495                 .mixers = { alc885_imac24_mixer },
9496                 .init_verbs = { alc885_imac24_init_verbs },
9497                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9498                 .dac_nids = alc882_dac_nids,
9499                 .dig_out_nid = ALC882_DIGOUT_NID,
9500                 .dig_in_nid = ALC882_DIGIN_NID,
9501                 .num_channel_mode = ARRAY_SIZE(alc882_ch_modes),
9502                 .channel_mode = alc882_ch_modes,
9503                 .input_mux = &alc882_capture_source,
9504                 .unsol_event = alc_automute_amp_unsol_event,
9505                 .setup = alc885_imac24_setup,
9506                 .init_hook = alc885_imac24_init_hook,
9507         },
9508         [ALC885_IMAC91] = {
9509                 .mixers = { alc885_imac91_mixer, alc882_chmode_mixer },
9510                 .init_verbs = { alc885_imac91_init_verbs,
9511                                 alc880_gpio1_init_verbs },
9512                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9513                 .dac_nids = alc882_dac_nids,
9514                 .channel_mode = alc885_mbp_4ch_modes,
9515                 .num_channel_mode = ARRAY_SIZE(alc885_mbp_4ch_modes),
9516                 .input_mux = &alc882_capture_source,
9517                 .dig_out_nid = ALC882_DIGOUT_NID,
9518                 .dig_in_nid = ALC882_DIGIN_NID,
9519                 .unsol_event = alc_automute_amp_unsol_event,
9520                 .setup = alc885_imac91_setup,
9521                 .init_hook = alc_automute_amp,
9522         },
9523         [ALC882_TARGA] = {
9524                 .mixers = { alc882_targa_mixer, alc882_chmode_mixer },
9525                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9526                                 alc880_gpio3_init_verbs, alc882_targa_verbs},
9527                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9528                 .dac_nids = alc882_dac_nids,
9529                 .dig_out_nid = ALC882_DIGOUT_NID,
9530                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9531                 .adc_nids = alc882_adc_nids,
9532                 .capsrc_nids = alc882_capsrc_nids,
9533                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9534                 .channel_mode = alc882_3ST_6ch_modes,
9535                 .need_dac_fix = 1,
9536                 .input_mux = &alc882_capture_source,
9537                 .unsol_event = alc882_targa_unsol_event,
9538                 .setup = alc882_targa_setup,
9539                 .init_hook = alc882_targa_automute,
9540         },
9541         [ALC882_ASUS_A7J] = {
9542                 .mixers = { alc882_asus_a7j_mixer, alc882_chmode_mixer },
9543                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9544                                 alc882_asus_a7j_verbs},
9545                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9546                 .dac_nids = alc882_dac_nids,
9547                 .dig_out_nid = ALC882_DIGOUT_NID,
9548                 .num_adc_nids = ARRAY_SIZE(alc882_adc_nids),
9549                 .adc_nids = alc882_adc_nids,
9550                 .capsrc_nids = alc882_capsrc_nids,
9551                 .num_channel_mode = ARRAY_SIZE(alc882_3ST_6ch_modes),
9552                 .channel_mode = alc882_3ST_6ch_modes,
9553                 .need_dac_fix = 1,
9554                 .input_mux = &alc882_capture_source,
9555         },
9556         [ALC882_ASUS_A7M] = {
9557                 .mixers = { alc882_asus_a7m_mixer, alc882_chmode_mixer },
9558                 .init_verbs = { alc882_base_init_verbs, alc882_adc1_init_verbs,
9559                                 alc882_eapd_verbs, alc880_gpio1_init_verbs,
9560                                 alc882_asus_a7m_verbs },
9561                 .num_dacs = ARRAY_SIZE(alc882_dac_nids),
9562                 .dac_nids = alc882_dac_nids,
9563                 .dig_out_nid = ALC882_DIGOUT_NID,
9564                 .num_channel_mode = ARRAY_SIZE(alc880_threestack_modes),
9565                 .channel_mode = alc880_threestack_modes,
9566                 .need_dac_fix = 1,
9567                 .input_mux = &alc882_capture_source,
9568         },
9569         [ALC883_3ST_2ch_DIG] = {
9570                 .mixers = { alc883_3ST_2ch_mixer },
9571                 .init_verbs = { alc883_init_verbs },
9572                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9573                 .dac_nids = alc883_dac_nids,
9574                 .dig_out_nid = ALC883_DIGOUT_NID,
9575                 .dig_in_nid = ALC883_DIGIN_NID,
9576                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9577                 .channel_mode = alc883_3ST_2ch_modes,
9578                 .input_mux = &alc883_capture_source,
9579         },
9580         [ALC883_3ST_6ch_DIG] = {
9581                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9582                 .init_verbs = { alc883_init_verbs },
9583                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9584                 .dac_nids = alc883_dac_nids,
9585                 .dig_out_nid = ALC883_DIGOUT_NID,
9586                 .dig_in_nid = ALC883_DIGIN_NID,
9587                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9588                 .channel_mode = alc883_3ST_6ch_modes,
9589                 .need_dac_fix = 1,
9590                 .input_mux = &alc883_capture_source,
9591         },
9592         [ALC883_3ST_6ch] = {
9593                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9594                 .init_verbs = { alc883_init_verbs },
9595                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9596                 .dac_nids = alc883_dac_nids,
9597                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9598                 .channel_mode = alc883_3ST_6ch_modes,
9599                 .need_dac_fix = 1,
9600                 .input_mux = &alc883_capture_source,
9601         },
9602         [ALC883_3ST_6ch_INTEL] = {
9603                 .mixers = { alc883_3ST_6ch_intel_mixer, alc883_chmode_mixer },
9604                 .init_verbs = { alc883_init_verbs },
9605                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9606                 .dac_nids = alc883_dac_nids,
9607                 .dig_out_nid = ALC883_DIGOUT_NID,
9608                 .dig_in_nid = ALC883_DIGIN_NID,
9609                 .slave_dig_outs = alc883_slave_dig_outs,
9610                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_intel_modes),
9611                 .channel_mode = alc883_3ST_6ch_intel_modes,
9612                 .need_dac_fix = 1,
9613                 .input_mux = &alc883_3stack_6ch_intel,
9614         },
9615         [ALC889A_INTEL] = {
9616                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9617                 .init_verbs = { alc885_init_verbs, alc885_init_input_verbs,
9618                                 alc_hp15_unsol_verbs },
9619                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9620                 .dac_nids = alc883_dac_nids,
9621                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9622                 .adc_nids = alc889_adc_nids,
9623                 .dig_out_nid = ALC883_DIGOUT_NID,
9624                 .dig_in_nid = ALC883_DIGIN_NID,
9625                 .slave_dig_outs = alc883_slave_dig_outs,
9626                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9627                 .channel_mode = alc889_8ch_intel_modes,
9628                 .capsrc_nids = alc889_capsrc_nids,
9629                 .input_mux = &alc889_capture_source,
9630                 .setup = alc889_automute_setup,
9631                 .init_hook = alc_automute_amp,
9632                 .unsol_event = alc_automute_amp_unsol_event,
9633                 .need_dac_fix = 1,
9634         },
9635         [ALC889_INTEL] = {
9636                 .mixers = { alc885_8ch_intel_mixer, alc883_chmode_mixer },
9637                 .init_verbs = { alc885_init_verbs, alc889_init_input_verbs,
9638                                 alc889_eapd_verbs, alc_hp15_unsol_verbs},
9639                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9640                 .dac_nids = alc883_dac_nids,
9641                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9642                 .adc_nids = alc889_adc_nids,
9643                 .dig_out_nid = ALC883_DIGOUT_NID,
9644                 .dig_in_nid = ALC883_DIGIN_NID,
9645                 .slave_dig_outs = alc883_slave_dig_outs,
9646                 .num_channel_mode = ARRAY_SIZE(alc889_8ch_intel_modes),
9647                 .channel_mode = alc889_8ch_intel_modes,
9648                 .capsrc_nids = alc889_capsrc_nids,
9649                 .input_mux = &alc889_capture_source,
9650                 .setup = alc889_automute_setup,
9651                 .init_hook = alc889_intel_init_hook,
9652                 .unsol_event = alc_automute_amp_unsol_event,
9653                 .need_dac_fix = 1,
9654         },
9655         [ALC883_6ST_DIG] = {
9656                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9657                 .init_verbs = { alc883_init_verbs },
9658                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9659                 .dac_nids = alc883_dac_nids,
9660                 .dig_out_nid = ALC883_DIGOUT_NID,
9661                 .dig_in_nid = ALC883_DIGIN_NID,
9662                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9663                 .channel_mode = alc883_sixstack_modes,
9664                 .input_mux = &alc883_capture_source,
9665         },
9666         [ALC883_TARGA_DIG] = {
9667                 .mixers = { alc883_targa_mixer, alc883_chmode_mixer },
9668                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9669                                 alc883_targa_verbs},
9670                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9671                 .dac_nids = alc883_dac_nids,
9672                 .dig_out_nid = ALC883_DIGOUT_NID,
9673                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9674                 .channel_mode = alc883_3ST_6ch_modes,
9675                 .need_dac_fix = 1,
9676                 .input_mux = &alc883_capture_source,
9677                 .unsol_event = alc883_targa_unsol_event,
9678                 .setup = alc882_targa_setup,
9679                 .init_hook = alc882_targa_automute,
9680         },
9681         [ALC883_TARGA_2ch_DIG] = {
9682                 .mixers = { alc883_targa_2ch_mixer},
9683                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9684                                 alc883_targa_verbs},
9685                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9686                 .dac_nids = alc883_dac_nids,
9687                 .adc_nids = alc883_adc_nids_alt,
9688                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9689                 .capsrc_nids = alc883_capsrc_nids,
9690                 .dig_out_nid = ALC883_DIGOUT_NID,
9691                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9692                 .channel_mode = alc883_3ST_2ch_modes,
9693                 .input_mux = &alc883_capture_source,
9694                 .unsol_event = alc883_targa_unsol_event,
9695                 .setup = alc882_targa_setup,
9696                 .init_hook = alc882_targa_automute,
9697         },
9698         [ALC883_TARGA_8ch_DIG] = {
9699                 .mixers = { alc883_targa_mixer, alc883_targa_8ch_mixer,
9700                             alc883_chmode_mixer },
9701                 .init_verbs = { alc883_init_verbs, alc880_gpio3_init_verbs,
9702                                 alc883_targa_verbs },
9703                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9704                 .dac_nids = alc883_dac_nids,
9705                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9706                 .adc_nids = alc883_adc_nids_rev,
9707                 .capsrc_nids = alc883_capsrc_nids_rev,
9708                 .dig_out_nid = ALC883_DIGOUT_NID,
9709                 .dig_in_nid = ALC883_DIGIN_NID,
9710                 .num_channel_mode = ARRAY_SIZE(alc883_4ST_8ch_modes),
9711                 .channel_mode = alc883_4ST_8ch_modes,
9712                 .need_dac_fix = 1,
9713                 .input_mux = &alc883_capture_source,
9714                 .unsol_event = alc883_targa_unsol_event,
9715                 .setup = alc882_targa_setup,
9716                 .init_hook = alc882_targa_automute,
9717         },
9718         [ALC883_ACER] = {
9719                 .mixers = { alc883_base_mixer },
9720                 /* On TravelMate laptops, GPIO 0 enables the internal speaker
9721                  * and the headphone jack.  Turn this on and rely on the
9722                  * standard mute methods whenever the user wants to turn
9723                  * these outputs off.
9724                  */
9725                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs },
9726                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9727                 .dac_nids = alc883_dac_nids,
9728                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9729                 .channel_mode = alc883_3ST_2ch_modes,
9730                 .input_mux = &alc883_capture_source,
9731         },
9732         [ALC883_ACER_ASPIRE] = {
9733                 .mixers = { alc883_acer_aspire_mixer },
9734                 .init_verbs = { alc883_init_verbs, alc883_acer_eapd_verbs },
9735                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9736                 .dac_nids = alc883_dac_nids,
9737                 .dig_out_nid = ALC883_DIGOUT_NID,
9738                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9739                 .channel_mode = alc883_3ST_2ch_modes,
9740                 .input_mux = &alc883_capture_source,
9741                 .unsol_event = alc_automute_amp_unsol_event,
9742                 .setup = alc883_acer_aspire_setup,
9743                 .init_hook = alc_automute_amp,
9744         },
9745         [ALC888_ACER_ASPIRE_4930G] = {
9746                 .mixers = { alc888_base_mixer,
9747                                 alc883_chmode_mixer },
9748                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9749                                 alc888_acer_aspire_4930g_verbs },
9750                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9751                 .dac_nids = alc883_dac_nids,
9752                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9753                 .adc_nids = alc883_adc_nids_rev,
9754                 .capsrc_nids = alc883_capsrc_nids_rev,
9755                 .dig_out_nid = ALC883_DIGOUT_NID,
9756                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9757                 .channel_mode = alc883_3ST_6ch_modes,
9758                 .need_dac_fix = 1,
9759                 .const_channel_count = 6,
9760                 .num_mux_defs =
9761                         ARRAY_SIZE(alc888_2_capture_sources),
9762                 .input_mux = alc888_2_capture_sources,
9763                 .unsol_event = alc_automute_amp_unsol_event,
9764                 .setup = alc888_acer_aspire_4930g_setup,
9765                 .init_hook = alc_automute_amp,
9766         },
9767         [ALC888_ACER_ASPIRE_6530G] = {
9768                 .mixers = { alc888_acer_aspire_6530_mixer },
9769                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9770                                 alc888_acer_aspire_6530g_verbs },
9771                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9772                 .dac_nids = alc883_dac_nids,
9773                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9774                 .adc_nids = alc883_adc_nids_rev,
9775                 .capsrc_nids = alc883_capsrc_nids_rev,
9776                 .dig_out_nid = ALC883_DIGOUT_NID,
9777                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9778                 .channel_mode = alc883_3ST_2ch_modes,
9779                 .num_mux_defs =
9780                         ARRAY_SIZE(alc888_2_capture_sources),
9781                 .input_mux = alc888_acer_aspire_6530_sources,
9782                 .unsol_event = alc_automute_amp_unsol_event,
9783                 .setup = alc888_acer_aspire_6530g_setup,
9784                 .init_hook = alc_automute_amp,
9785         },
9786         [ALC888_ACER_ASPIRE_8930G] = {
9787                 .mixers = { alc889_acer_aspire_8930g_mixer,
9788                                 alc883_chmode_mixer },
9789                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9790                                 alc889_acer_aspire_8930g_verbs,
9791                                 alc889_eapd_verbs},
9792                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9793                 .dac_nids = alc883_dac_nids,
9794                 .num_adc_nids = ARRAY_SIZE(alc889_adc_nids),
9795                 .adc_nids = alc889_adc_nids,
9796                 .capsrc_nids = alc889_capsrc_nids,
9797                 .dig_out_nid = ALC883_DIGOUT_NID,
9798                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9799                 .channel_mode = alc883_3ST_6ch_modes,
9800                 .need_dac_fix = 1,
9801                 .const_channel_count = 6,
9802                 .num_mux_defs =
9803                         ARRAY_SIZE(alc889_capture_sources),
9804                 .input_mux = alc889_capture_sources,
9805                 .unsol_event = alc_automute_amp_unsol_event,
9806                 .setup = alc889_acer_aspire_8930g_setup,
9807                 .init_hook = alc_automute_amp,
9808 #ifdef CONFIG_SND_HDA_POWER_SAVE
9809                 .power_hook = alc_power_eapd,
9810 #endif
9811         },
9812         [ALC888_ACER_ASPIRE_7730G] = {
9813                 .mixers = { alc883_3ST_6ch_mixer,
9814                                 alc883_chmode_mixer },
9815                 .init_verbs = { alc883_init_verbs, alc880_gpio1_init_verbs,
9816                                 alc888_acer_aspire_7730G_verbs },
9817                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9818                 .dac_nids = alc883_dac_nids,
9819                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
9820                 .adc_nids = alc883_adc_nids_rev,
9821                 .capsrc_nids = alc883_capsrc_nids_rev,
9822                 .dig_out_nid = ALC883_DIGOUT_NID,
9823                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9824                 .channel_mode = alc883_3ST_6ch_modes,
9825                 .need_dac_fix = 1,
9826                 .const_channel_count = 6,
9827                 .input_mux = &alc883_capture_source,
9828                 .unsol_event = alc_automute_amp_unsol_event,
9829                 .setup = alc888_acer_aspire_6530g_setup,
9830                 .init_hook = alc_automute_amp,
9831         },
9832         [ALC883_MEDION] = {
9833                 .mixers = { alc883_fivestack_mixer,
9834                             alc883_chmode_mixer },
9835                 .init_verbs = { alc883_init_verbs,
9836                                 alc883_medion_eapd_verbs },
9837                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9838                 .dac_nids = alc883_dac_nids,
9839                 .adc_nids = alc883_adc_nids_alt,
9840                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9841                 .capsrc_nids = alc883_capsrc_nids,
9842                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9843                 .channel_mode = alc883_sixstack_modes,
9844                 .input_mux = &alc883_capture_source,
9845         },
9846         [ALC883_MEDION_MD2] = {
9847                 .mixers = { alc883_medion_md2_mixer},
9848                 .init_verbs = { alc883_init_verbs, alc883_medion_md2_verbs},
9849                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9850                 .dac_nids = alc883_dac_nids,
9851                 .dig_out_nid = ALC883_DIGOUT_NID,
9852                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9853                 .channel_mode = alc883_3ST_2ch_modes,
9854                 .input_mux = &alc883_capture_source,
9855                 .unsol_event = alc_automute_amp_unsol_event,
9856                 .setup = alc883_medion_md2_setup,
9857                 .init_hook = alc_automute_amp,
9858         },
9859         [ALC883_MEDION_WIM2160] = {
9860                 .mixers = { alc883_medion_wim2160_mixer },
9861                 .init_verbs = { alc883_init_verbs, alc883_medion_wim2160_verbs },
9862                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9863                 .dac_nids = alc883_dac_nids,
9864                 .dig_out_nid = ALC883_DIGOUT_NID,
9865                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
9866                 .adc_nids = alc883_adc_nids,
9867                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9868                 .channel_mode = alc883_3ST_2ch_modes,
9869                 .input_mux = &alc883_capture_source,
9870                 .unsol_event = alc_automute_amp_unsol_event,
9871                 .setup = alc883_medion_wim2160_setup,
9872                 .init_hook = alc_automute_amp,
9873         },
9874         [ALC883_LAPTOP_EAPD] = {
9875                 .mixers = { alc883_base_mixer },
9876                 .init_verbs = { alc883_init_verbs, alc882_eapd_verbs },
9877                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9878                 .dac_nids = alc883_dac_nids,
9879                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9880                 .channel_mode = alc883_3ST_2ch_modes,
9881                 .input_mux = &alc883_capture_source,
9882         },
9883         [ALC883_CLEVO_M540R] = {
9884                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9885                 .init_verbs = { alc883_init_verbs, alc883_clevo_m540r_verbs },
9886                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9887                 .dac_nids = alc883_dac_nids,
9888                 .dig_out_nid = ALC883_DIGOUT_NID,
9889                 .dig_in_nid = ALC883_DIGIN_NID,
9890                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_clevo_modes),
9891                 .channel_mode = alc883_3ST_6ch_clevo_modes,
9892                 .need_dac_fix = 1,
9893                 .input_mux = &alc883_capture_source,
9894                 /* This machine has the hardware HP auto-muting, thus
9895                  * we need no software mute via unsol event
9896                  */
9897         },
9898         [ALC883_CLEVO_M720] = {
9899                 .mixers = { alc883_clevo_m720_mixer },
9900                 .init_verbs = { alc883_init_verbs, alc883_clevo_m720_verbs },
9901                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9902                 .dac_nids = alc883_dac_nids,
9903                 .dig_out_nid = ALC883_DIGOUT_NID,
9904                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9905                 .channel_mode = alc883_3ST_2ch_modes,
9906                 .input_mux = &alc883_capture_source,
9907                 .unsol_event = alc883_clevo_m720_unsol_event,
9908                 .setup = alc883_clevo_m720_setup,
9909                 .init_hook = alc883_clevo_m720_init_hook,
9910         },
9911         [ALC883_LENOVO_101E_2ch] = {
9912                 .mixers = { alc883_lenovo_101e_2ch_mixer},
9913                 .init_verbs = { alc883_init_verbs, alc883_lenovo_101e_verbs},
9914                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9915                 .dac_nids = alc883_dac_nids,
9916                 .adc_nids = alc883_adc_nids_alt,
9917                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_alt),
9918                 .capsrc_nids = alc883_capsrc_nids,
9919                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9920                 .channel_mode = alc883_3ST_2ch_modes,
9921                 .input_mux = &alc883_lenovo_101e_capture_source,
9922                 .unsol_event = alc883_lenovo_101e_unsol_event,
9923                 .init_hook = alc883_lenovo_101e_all_automute,
9924         },
9925         [ALC883_LENOVO_NB0763] = {
9926                 .mixers = { alc883_lenovo_nb0763_mixer },
9927                 .init_verbs = { alc883_init_verbs, alc883_lenovo_nb0763_verbs},
9928                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9929                 .dac_nids = alc883_dac_nids,
9930                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9931                 .channel_mode = alc883_3ST_2ch_modes,
9932                 .need_dac_fix = 1,
9933                 .input_mux = &alc883_lenovo_nb0763_capture_source,
9934                 .unsol_event = alc_automute_amp_unsol_event,
9935                 .setup = alc883_medion_md2_setup,
9936                 .init_hook = alc_automute_amp,
9937         },
9938         [ALC888_LENOVO_MS7195_DIG] = {
9939                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9940                 .init_verbs = { alc883_init_verbs, alc888_lenovo_ms7195_verbs},
9941                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9942                 .dac_nids = alc883_dac_nids,
9943                 .dig_out_nid = ALC883_DIGOUT_NID,
9944                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
9945                 .channel_mode = alc883_3ST_6ch_modes,
9946                 .need_dac_fix = 1,
9947                 .input_mux = &alc883_capture_source,
9948                 .unsol_event = alc883_lenovo_ms7195_unsol_event,
9949                 .init_hook = alc888_lenovo_ms7195_front_automute,
9950         },
9951         [ALC883_HAIER_W66] = {
9952                 .mixers = { alc883_targa_2ch_mixer},
9953                 .init_verbs = { alc883_init_verbs, alc883_haier_w66_verbs},
9954                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9955                 .dac_nids = alc883_dac_nids,
9956                 .dig_out_nid = ALC883_DIGOUT_NID,
9957                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9958                 .channel_mode = alc883_3ST_2ch_modes,
9959                 .input_mux = &alc883_capture_source,
9960                 .unsol_event = alc_automute_amp_unsol_event,
9961                 .setup = alc883_haier_w66_setup,
9962                 .init_hook = alc_automute_amp,
9963         },
9964         [ALC888_3ST_HP] = {
9965                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
9966                 .init_verbs = { alc883_init_verbs, alc888_3st_hp_verbs },
9967                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9968                 .dac_nids = alc883_dac_nids,
9969                 .num_channel_mode = ARRAY_SIZE(alc888_3st_hp_modes),
9970                 .channel_mode = alc888_3st_hp_modes,
9971                 .need_dac_fix = 1,
9972                 .input_mux = &alc883_capture_source,
9973                 .unsol_event = alc_automute_amp_unsol_event,
9974                 .setup = alc888_3st_hp_setup,
9975                 .init_hook = alc_automute_amp,
9976         },
9977         [ALC888_6ST_DELL] = {
9978                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
9979                 .init_verbs = { alc883_init_verbs, alc888_6st_dell_verbs },
9980                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9981                 .dac_nids = alc883_dac_nids,
9982                 .dig_out_nid = ALC883_DIGOUT_NID,
9983                 .dig_in_nid = ALC883_DIGIN_NID,
9984                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
9985                 .channel_mode = alc883_sixstack_modes,
9986                 .input_mux = &alc883_capture_source,
9987                 .unsol_event = alc_automute_amp_unsol_event,
9988                 .setup = alc888_6st_dell_setup,
9989                 .init_hook = alc_automute_amp,
9990         },
9991         [ALC883_MITAC] = {
9992                 .mixers = { alc883_mitac_mixer },
9993                 .init_verbs = { alc883_init_verbs, alc883_mitac_verbs },
9994                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
9995                 .dac_nids = alc883_dac_nids,
9996                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
9997                 .channel_mode = alc883_3ST_2ch_modes,
9998                 .input_mux = &alc883_capture_source,
9999                 .unsol_event = alc_automute_amp_unsol_event,
10000                 .setup = alc883_mitac_setup,
10001                 .init_hook = alc_automute_amp,
10002         },
10003         [ALC883_FUJITSU_PI2515] = {
10004                 .mixers = { alc883_2ch_fujitsu_pi2515_mixer },
10005                 .init_verbs = { alc883_init_verbs,
10006                                 alc883_2ch_fujitsu_pi2515_verbs},
10007                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10008                 .dac_nids = alc883_dac_nids,
10009                 .dig_out_nid = ALC883_DIGOUT_NID,
10010                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10011                 .channel_mode = alc883_3ST_2ch_modes,
10012                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10013                 .unsol_event = alc_automute_amp_unsol_event,
10014                 .setup = alc883_2ch_fujitsu_pi2515_setup,
10015                 .init_hook = alc_automute_amp,
10016         },
10017         [ALC888_FUJITSU_XA3530] = {
10018                 .mixers = { alc888_base_mixer, alc883_chmode_mixer },
10019                 .init_verbs = { alc883_init_verbs,
10020                         alc888_fujitsu_xa3530_verbs },
10021                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10022                 .dac_nids = alc883_dac_nids,
10023                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids_rev),
10024                 .adc_nids = alc883_adc_nids_rev,
10025                 .capsrc_nids = alc883_capsrc_nids_rev,
10026                 .dig_out_nid = ALC883_DIGOUT_NID,
10027                 .num_channel_mode = ARRAY_SIZE(alc888_4ST_8ch_intel_modes),
10028                 .channel_mode = alc888_4ST_8ch_intel_modes,
10029                 .num_mux_defs =
10030                         ARRAY_SIZE(alc888_2_capture_sources),
10031                 .input_mux = alc888_2_capture_sources,
10032                 .unsol_event = alc_automute_amp_unsol_event,
10033                 .setup = alc888_fujitsu_xa3530_setup,
10034                 .init_hook = alc_automute_amp,
10035         },
10036         [ALC888_LENOVO_SKY] = {
10037                 .mixers = { alc888_lenovo_sky_mixer, alc883_chmode_mixer },
10038                 .init_verbs = { alc883_init_verbs, alc888_lenovo_sky_verbs},
10039                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10040                 .dac_nids = alc883_dac_nids,
10041                 .dig_out_nid = ALC883_DIGOUT_NID,
10042                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10043                 .channel_mode = alc883_sixstack_modes,
10044                 .need_dac_fix = 1,
10045                 .input_mux = &alc883_lenovo_sky_capture_source,
10046                 .unsol_event = alc_automute_amp_unsol_event,
10047                 .setup = alc888_lenovo_sky_setup,
10048                 .init_hook = alc_automute_amp,
10049         },
10050         [ALC888_ASUS_M90V] = {
10051                 .mixers = { alc883_3ST_6ch_mixer, alc883_chmode_mixer },
10052                 .init_verbs = { alc883_init_verbs, alc888_asus_m90v_verbs },
10053                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10054                 .dac_nids = alc883_dac_nids,
10055                 .dig_out_nid = ALC883_DIGOUT_NID,
10056                 .dig_in_nid = ALC883_DIGIN_NID,
10057                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_6ch_modes),
10058                 .channel_mode = alc883_3ST_6ch_modes,
10059                 .need_dac_fix = 1,
10060                 .input_mux = &alc883_fujitsu_pi2515_capture_source,
10061                 .unsol_event = alc_sku_unsol_event,
10062                 .setup = alc883_mode2_setup,
10063                 .init_hook = alc_inithook,
10064         },
10065         [ALC888_ASUS_EEE1601] = {
10066                 .mixers = { alc883_asus_eee1601_mixer },
10067                 .cap_mixer = alc883_asus_eee1601_cap_mixer,
10068                 .init_verbs = { alc883_init_verbs, alc888_asus_eee1601_verbs },
10069                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10070                 .dac_nids = alc883_dac_nids,
10071                 .dig_out_nid = ALC883_DIGOUT_NID,
10072                 .dig_in_nid = ALC883_DIGIN_NID,
10073                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10074                 .channel_mode = alc883_3ST_2ch_modes,
10075                 .need_dac_fix = 1,
10076                 .input_mux = &alc883_asus_eee1601_capture_source,
10077                 .unsol_event = alc_sku_unsol_event,
10078                 .init_hook = alc883_eee1601_inithook,
10079         },
10080         [ALC1200_ASUS_P5Q] = {
10081                 .mixers = { alc883_base_mixer, alc883_chmode_mixer },
10082                 .init_verbs = { alc883_init_verbs },
10083                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10084                 .dac_nids = alc883_dac_nids,
10085                 .dig_out_nid = ALC1200_DIGOUT_NID,
10086                 .dig_in_nid = ALC883_DIGIN_NID,
10087                 .slave_dig_outs = alc1200_slave_dig_outs,
10088                 .num_channel_mode = ARRAY_SIZE(alc883_sixstack_modes),
10089                 .channel_mode = alc883_sixstack_modes,
10090                 .input_mux = &alc883_capture_source,
10091         },
10092         [ALC889A_MB31] = {
10093                 .mixers = { alc889A_mb31_mixer, alc883_chmode_mixer},
10094                 .init_verbs = { alc883_init_verbs, alc889A_mb31_verbs,
10095                         alc880_gpio1_init_verbs },
10096                 .adc_nids = alc883_adc_nids,
10097                 .num_adc_nids = ARRAY_SIZE(alc883_adc_nids),
10098                 .capsrc_nids = alc883_capsrc_nids,
10099                 .dac_nids = alc883_dac_nids,
10100                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10101                 .channel_mode = alc889A_mb31_6ch_modes,
10102                 .num_channel_mode = ARRAY_SIZE(alc889A_mb31_6ch_modes),
10103                 .input_mux = &alc889A_mb31_capture_source,
10104                 .dig_out_nid = ALC883_DIGOUT_NID,
10105                 .unsol_event = alc889A_mb31_unsol_event,
10106                 .init_hook = alc889A_mb31_automute,
10107         },
10108         [ALC883_SONY_VAIO_TT] = {
10109                 .mixers = { alc883_vaiott_mixer },
10110                 .init_verbs = { alc883_init_verbs, alc883_vaiott_verbs },
10111                 .num_dacs = ARRAY_SIZE(alc883_dac_nids),
10112                 .dac_nids = alc883_dac_nids,
10113                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
10114                 .channel_mode = alc883_3ST_2ch_modes,
10115                 .input_mux = &alc883_capture_source,
10116                 .unsol_event = alc_automute_amp_unsol_event,
10117                 .setup = alc883_vaiott_setup,
10118                 .init_hook = alc_automute_amp,
10119         },
10120 };
10121
10122
10123 /*
10124  * Pin config fixes
10125  */
10126 enum {
10127         PINFIX_ABIT_AW9D_MAX
10128 };
10129
10130 static struct alc_pincfg alc882_abit_aw9d_pinfix[] = {
10131         { 0x15, 0x01080104 }, /* side */
10132         { 0x16, 0x01011012 }, /* rear */
10133         { 0x17, 0x01016011 }, /* clfe */
10134         { }
10135 };
10136
10137 static const struct alc_fixup alc882_fixups[] = {
10138         [PINFIX_ABIT_AW9D_MAX] = {
10139                 .pins = alc882_abit_aw9d_pinfix
10140         },
10141 };
10142
10143 static struct snd_pci_quirk alc882_fixup_tbl[] = {
10144         SND_PCI_QUIRK(0x147b, 0x107a, "Abit AW9D-MAX", PINFIX_ABIT_AW9D_MAX),
10145         {}
10146 };
10147
10148 /*
10149  * BIOS auto configuration
10150  */
10151 static int alc882_auto_create_input_ctls(struct hda_codec *codec,
10152                                                 const struct auto_pin_cfg *cfg)
10153 {
10154         return alc_auto_create_input_ctls(codec, cfg, 0x0b, 0x23, 0x22);
10155 }
10156
10157 static void alc882_auto_set_output_and_unmute(struct hda_codec *codec,
10158                                               hda_nid_t nid, int pin_type,
10159                                               int dac_idx)
10160 {
10161         /* set as output */
10162         struct alc_spec *spec = codec->spec;
10163         int idx;
10164
10165         alc_set_pin_output(codec, nid, pin_type);
10166         if (dac_idx >= spec->multiout.num_dacs)
10167                 return;
10168         if (spec->multiout.dac_nids[dac_idx] == 0x25)
10169                 idx = 4;
10170         else
10171                 idx = spec->multiout.dac_nids[dac_idx] - 2;
10172         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
10173
10174 }
10175
10176 static void alc882_auto_init_multi_out(struct hda_codec *codec)
10177 {
10178         struct alc_spec *spec = codec->spec;
10179         int i;
10180
10181         for (i = 0; i <= HDA_SIDE; i++) {
10182                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
10183                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
10184                 if (nid)
10185                         alc882_auto_set_output_and_unmute(codec, nid, pin_type,
10186                                                           i);
10187         }
10188 }
10189
10190 static void alc882_auto_init_hp_out(struct hda_codec *codec)
10191 {
10192         struct alc_spec *spec = codec->spec;
10193         hda_nid_t pin;
10194
10195         pin = spec->autocfg.hp_pins[0];
10196         if (pin) /* connect to front */
10197                 /* use dac 0 */
10198                 alc882_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
10199         pin = spec->autocfg.speaker_pins[0];
10200         if (pin)
10201                 alc882_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
10202 }
10203
10204 static void alc882_auto_init_analog_input(struct hda_codec *codec)
10205 {
10206         struct alc_spec *spec = codec->spec;
10207         int i;
10208
10209         for (i = 0; i < AUTO_PIN_LAST; i++) {
10210                 hda_nid_t nid = spec->autocfg.input_pins[i];
10211                 if (!nid)
10212                         continue;
10213                 alc_set_input_pin(codec, nid, i);
10214                 if (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP)
10215                         snd_hda_codec_write(codec, nid, 0,
10216                                             AC_VERB_SET_AMP_GAIN_MUTE,
10217                                             AMP_OUT_MUTE);
10218         }
10219 }
10220
10221 static void alc882_auto_init_input_src(struct hda_codec *codec)
10222 {
10223         struct alc_spec *spec = codec->spec;
10224         int c;
10225
10226         for (c = 0; c < spec->num_adc_nids; c++) {
10227                 hda_nid_t conn_list[HDA_MAX_NUM_INPUTS];
10228                 hda_nid_t nid = spec->capsrc_nids[c];
10229                 unsigned int mux_idx;
10230                 const struct hda_input_mux *imux;
10231                 int conns, mute, idx, item;
10232
10233                 conns = snd_hda_get_connections(codec, nid, conn_list,
10234                                                 ARRAY_SIZE(conn_list));
10235                 if (conns < 0)
10236                         continue;
10237                 mux_idx = c >= spec->num_mux_defs ? 0 : c;
10238                 imux = &spec->input_mux[mux_idx];
10239                 if (!imux->num_items && mux_idx > 0)
10240                         imux = &spec->input_mux[0];
10241                 for (idx = 0; idx < conns; idx++) {
10242                         /* if the current connection is the selected one,
10243                          * unmute it as default - otherwise mute it
10244                          */
10245                         mute = AMP_IN_MUTE(idx);
10246                         for (item = 0; item < imux->num_items; item++) {
10247                                 if (imux->items[item].index == idx) {
10248                                         if (spec->cur_mux[c] == item)
10249                                                 mute = AMP_IN_UNMUTE(idx);
10250                                         break;
10251                                 }
10252                         }
10253                         /* check if we have a selector or mixer
10254                          * we could check for the widget type instead, but
10255                          * just check for Amp-In presence (in case of mixer
10256                          * without amp-in there is something wrong, this
10257                          * function shouldn't be used or capsrc nid is wrong)
10258                          */
10259                         if (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)
10260                                 snd_hda_codec_write(codec, nid, 0,
10261                                                     AC_VERB_SET_AMP_GAIN_MUTE,
10262                                                     mute);
10263                         else if (mute != AMP_IN_MUTE(idx))
10264                                 snd_hda_codec_write(codec, nid, 0,
10265                                                     AC_VERB_SET_CONNECT_SEL,
10266                                                     idx);
10267                 }
10268         }
10269 }
10270
10271 /* add mic boosts if needed */
10272 static int alc_auto_add_mic_boost(struct hda_codec *codec)
10273 {
10274         struct alc_spec *spec = codec->spec;
10275         int err;
10276         hda_nid_t nid;
10277
10278         nid = spec->autocfg.input_pins[AUTO_PIN_MIC];
10279         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10280                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10281                                   "Mic Boost",
10282                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10283                 if (err < 0)
10284                         return err;
10285         }
10286         nid = spec->autocfg.input_pins[AUTO_PIN_FRONT_MIC];
10287         if (nid && (get_wcaps(codec, nid) & AC_WCAP_IN_AMP)) {
10288                 err = add_control(spec, ALC_CTL_WIDGET_VOL,
10289                                   "Front Mic Boost",
10290                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
10291                 if (err < 0)
10292                         return err;
10293         }
10294         return 0;
10295 }
10296
10297 /* almost identical with ALC880 parser... */
10298 static int alc882_parse_auto_config(struct hda_codec *codec)
10299 {
10300         struct alc_spec *spec = codec->spec;
10301         static hda_nid_t alc882_ignore[] = { 0x1d, 0 };
10302         int i, err;
10303
10304         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
10305                                            alc882_ignore);
10306         if (err < 0)
10307                 return err;
10308         if (!spec->autocfg.line_outs)
10309                 return 0; /* can't find valid BIOS pin config */
10310
10311         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
10312         if (err < 0)
10313                 return err;
10314         err = alc880_auto_create_multi_out_ctls(spec, &spec->autocfg);
10315         if (err < 0)
10316                 return err;
10317         err = alc880_auto_create_extra_out(spec,
10318                                            spec->autocfg.speaker_pins[0],
10319                                            "Speaker");
10320         if (err < 0)
10321                 return err;
10322         err = alc880_auto_create_extra_out(spec, spec->autocfg.hp_pins[0],
10323                                            "Headphone");
10324         if (err < 0)
10325                 return err;
10326         err = alc882_auto_create_input_ctls(codec, &spec->autocfg);
10327         if (err < 0)
10328                 return err;
10329
10330         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
10331
10332         /* check multiple SPDIF-out (for recent codecs) */
10333         for (i = 0; i < spec->autocfg.dig_outs; i++) {
10334                 hda_nid_t dig_nid;
10335                 err = snd_hda_get_connections(codec,
10336                                               spec->autocfg.dig_out_pins[i],
10337                                               &dig_nid, 1);
10338                 if (err < 0)
10339                         continue;
10340                 if (!i)
10341                         spec->multiout.dig_out_nid = dig_nid;
10342                 else {
10343                         spec->multiout.slave_dig_outs = spec->slave_dig_outs;
10344                         if (i >= ARRAY_SIZE(spec->slave_dig_outs) - 1)
10345                                 break;
10346                         spec->slave_dig_outs[i - 1] = dig_nid;
10347                 }
10348         }
10349         if (spec->autocfg.dig_in_pin)
10350                 spec->dig_in_nid = ALC880_DIGIN_NID;
10351
10352         if (spec->kctls.list)
10353                 add_mixer(spec, spec->kctls.list);
10354
10355         add_verb(spec, alc883_auto_init_verbs);
10356         /* if ADC 0x07 is available, initialize it, too */
10357         if (get_wcaps_type(get_wcaps(codec, 0x07)) == AC_WID_AUD_IN)
10358                 add_verb(spec, alc882_adc1_init_verbs);
10359
10360         spec->num_mux_defs = 1;
10361         spec->input_mux = &spec->private_imux[0];
10362
10363         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
10364
10365         err = alc_auto_add_mic_boost(codec);
10366         if (err < 0)
10367                 return err;
10368
10369         return 1; /* config found */
10370 }
10371
10372 /* additional initialization for auto-configuration model */
10373 static void alc882_auto_init(struct hda_codec *codec)
10374 {
10375         struct alc_spec *spec = codec->spec;
10376         alc882_auto_init_multi_out(codec);
10377         alc882_auto_init_hp_out(codec);
10378         alc882_auto_init_analog_input(codec);
10379         alc882_auto_init_input_src(codec);
10380         if (spec->unsol_event)
10381                 alc_inithook(codec);
10382 }
10383
10384 static int patch_alc882(struct hda_codec *codec)
10385 {
10386         struct alc_spec *spec;
10387         int err, board_config;
10388
10389         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
10390         if (spec == NULL)
10391                 return -ENOMEM;
10392
10393         codec->spec = spec;
10394
10395         switch (codec->vendor_id) {
10396         case 0x10ec0882:
10397         case 0x10ec0885:
10398                 break;
10399         default:
10400                 /* ALC883 and variants */
10401                 alc_fix_pll_init(codec, 0x20, 0x0a, 10);
10402                 break;
10403         }
10404
10405         board_config = snd_hda_check_board_config(codec, ALC882_MODEL_LAST,
10406                                                   alc882_models,
10407                                                   alc882_cfg_tbl);
10408
10409         if (board_config < 0 || board_config >= ALC882_MODEL_LAST)
10410                 board_config = snd_hda_check_board_codec_sid_config(codec,
10411                         ALC882_MODEL_LAST, alc882_models, alc882_ssid_cfg_tbl);
10412
10413         if (board_config < 0 || board_config >= ALC882_MODEL_LAST) {
10414                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
10415                        codec->chip_name);
10416                 board_config = ALC882_AUTO;
10417         }
10418
10419         alc_pick_fixup(codec, alc882_fixup_tbl, alc882_fixups);
10420
10421         if (board_config == ALC882_AUTO) {
10422                 /* automatic parse from the BIOS config */
10423                 err = alc882_parse_auto_config(codec);
10424                 if (err < 0) {
10425                         alc_free(codec);
10426                         return err;
10427                 } else if (!err) {
10428                         printk(KERN_INFO
10429                                "hda_codec: Cannot set up configuration "
10430                                "from BIOS.  Using base mode...\n");
10431                         board_config = ALC882_3ST_DIG;
10432                 }
10433         }
10434
10435         err = snd_hda_attach_beep_device(codec, 0x1);
10436         if (err < 0) {
10437                 alc_free(codec);
10438                 return err;
10439         }
10440
10441         if (board_config != ALC882_AUTO)
10442                 setup_preset(codec, &alc882_presets[board_config]);
10443
10444         spec->stream_analog_playback = &alc882_pcm_analog_playback;
10445         spec->stream_analog_capture = &alc882_pcm_analog_capture;
10446         /* FIXME: setup DAC5 */
10447         /*spec->stream_analog_alt_playback = &alc880_pcm_analog_alt_playback;*/
10448         spec->stream_analog_alt_capture = &alc880_pcm_analog_alt_capture;
10449
10450         spec->stream_digital_playback = &alc882_pcm_digital_playback;
10451         spec->stream_digital_capture = &alc882_pcm_digital_capture;
10452
10453         if (codec->vendor_id == 0x10ec0888)
10454                 spec->init_amp = ALC_INIT_DEFAULT; /* always initialize */
10455
10456         if (!spec->adc_nids && spec->input_mux) {
10457                 int i, j;
10458                 spec->num_adc_nids = 0;
10459                 for (i = 0; i < ARRAY_SIZE(alc882_adc_nids); i++) {
10460                         const struct hda_input_mux *imux = spec->input_mux;
10461                         hda_nid_t cap;
10462                         hda_nid_t items[16];
10463                         hda_nid_t nid = alc882_adc_nids[i];
10464                         unsigned int wcap = get_wcaps(codec, nid);
10465                         /* get type */
10466                         wcap = get_wcaps_type(wcap);
10467                         if (wcap != AC_WID_AUD_IN)
10468                                 continue;
10469                         spec->private_adc_nids[spec->num_adc_nids] = nid;
10470                         err = snd_hda_get_connections(codec, nid, &cap, 1);
10471                         if (err < 0)
10472                                 continue;
10473                         err = snd_hda_get_connections(codec, cap, items,
10474                                                       ARRAY_SIZE(items));
10475                         if (err < 0)
10476                                 continue;
10477                         for (j = 0; j < imux->num_items; j++)
10478                                 if (imux->items[j].index >= err)
10479                                         break;
10480                         if (j < imux->num_items)
10481                                 continue;
10482                         spec->private_capsrc_nids[spec->num_adc_nids] = cap;
10483                         spec->num_adc_nids++;
10484                 }
10485                 spec->adc_nids = spec->private_adc_nids;
10486                 spec->capsrc_nids = spec->private_capsrc_nids;
10487         }
10488
10489         set_capture_mixer(codec);
10490         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
10491
10492         spec->vmaster_nid = 0x0c;
10493
10494         codec->patch_ops = alc_patch_ops;
10495         if (board_config == ALC882_AUTO)
10496                 spec->init_hook = alc882_auto_init;
10497 #ifdef CONFIG_SND_HDA_POWER_SAVE
10498         if (!spec->loopback.amplist)
10499                 spec->loopback.amplist = alc882_loopbacks;
10500 #endif
10501
10502         return 0;
10503 }
10504
10505
10506 /*
10507  * ALC262 support
10508  */
10509
10510 #define ALC262_DIGOUT_NID       ALC880_DIGOUT_NID
10511 #define ALC262_DIGIN_NID        ALC880_DIGIN_NID
10512
10513 #define alc262_dac_nids         alc260_dac_nids
10514 #define alc262_adc_nids         alc882_adc_nids
10515 #define alc262_adc_nids_alt     alc882_adc_nids_alt
10516 #define alc262_capsrc_nids      alc882_capsrc_nids
10517 #define alc262_capsrc_nids_alt  alc882_capsrc_nids_alt
10518
10519 #define alc262_modes            alc260_modes
10520 #define alc262_capture_source   alc882_capture_source
10521
10522 static hda_nid_t alc262_dmic_adc_nids[1] = {
10523         /* ADC0 */
10524         0x09
10525 };
10526
10527 static hda_nid_t alc262_dmic_capsrc_nids[1] = { 0x22 };
10528
10529 static struct snd_kcontrol_new alc262_base_mixer[] = {
10530         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10531         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10532         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10533         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10534         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10535         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10536         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10537         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10538         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10539         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10540         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10541         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10542         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0D, 0x0, HDA_OUTPUT),
10543         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10544         HDA_CODEC_VOLUME_MONO("Mono Playback Volume", 0x0e, 2, 0x0, HDA_OUTPUT),
10545         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
10546         { } /* end */
10547 };
10548
10549 /* update HP, line and mono-out pins according to the master switch */
10550 static void alc262_hp_master_update(struct hda_codec *codec)
10551 {
10552         struct alc_spec *spec = codec->spec;
10553         int val = spec->master_sw;
10554
10555         /* HP & line-out */
10556         snd_hda_codec_write_cache(codec, 0x1b, 0,
10557                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10558                                   val ? PIN_HP : 0);
10559         snd_hda_codec_write_cache(codec, 0x15, 0,
10560                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10561                                   val ? PIN_HP : 0);
10562         /* mono (speaker) depending on the HP jack sense */
10563         val = val && !spec->jack_present;
10564         snd_hda_codec_write_cache(codec, 0x16, 0,
10565                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
10566                                   val ? PIN_OUT : 0);
10567 }
10568
10569 static void alc262_hp_bpc_automute(struct hda_codec *codec)
10570 {
10571         struct alc_spec *spec = codec->spec;
10572
10573         spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
10574         alc262_hp_master_update(codec);
10575 }
10576
10577 static void alc262_hp_bpc_unsol_event(struct hda_codec *codec, unsigned int res)
10578 {
10579         if ((res >> 26) != ALC880_HP_EVENT)
10580                 return;
10581         alc262_hp_bpc_automute(codec);
10582 }
10583
10584 static void alc262_hp_wildwest_automute(struct hda_codec *codec)
10585 {
10586         struct alc_spec *spec = codec->spec;
10587
10588         spec->jack_present = snd_hda_jack_detect(codec, 0x15);
10589         alc262_hp_master_update(codec);
10590 }
10591
10592 static void alc262_hp_wildwest_unsol_event(struct hda_codec *codec,
10593                                            unsigned int res)
10594 {
10595         if ((res >> 26) != ALC880_HP_EVENT)
10596                 return;
10597         alc262_hp_wildwest_automute(codec);
10598 }
10599
10600 #define alc262_hp_master_sw_get         alc260_hp_master_sw_get
10601
10602 static int alc262_hp_master_sw_put(struct snd_kcontrol *kcontrol,
10603                                    struct snd_ctl_elem_value *ucontrol)
10604 {
10605         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10606         struct alc_spec *spec = codec->spec;
10607         int val = !!*ucontrol->value.integer.value;
10608
10609         if (val == spec->master_sw)
10610                 return 0;
10611         spec->master_sw = val;
10612         alc262_hp_master_update(codec);
10613         return 1;
10614 }
10615
10616 #define ALC262_HP_MASTER_SWITCH                                 \
10617         {                                                       \
10618                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10619                 .name = "Master Playback Switch",               \
10620                 .info = snd_ctl_boolean_mono_info,              \
10621                 .get = alc262_hp_master_sw_get,                 \
10622                 .put = alc262_hp_master_sw_put,                 \
10623         }, \
10624         {                                                       \
10625                 .iface = NID_MAPPING,                           \
10626                 .name = "Master Playback Switch",               \
10627                 .private_value = 0x15 | (0x16 << 8) | (0x1b << 16),     \
10628         }
10629
10630
10631 static struct snd_kcontrol_new alc262_HP_BPC_mixer[] = {
10632         ALC262_HP_MASTER_SWITCH,
10633         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10634         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10635         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10636         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10637                               HDA_OUTPUT),
10638         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10639                             HDA_OUTPUT),
10640         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10641         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10642         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10643         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10644         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10645         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10646         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10647         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10648         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10649         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10650         HDA_CODEC_VOLUME("AUX IN Playback Volume", 0x0b, 0x06, HDA_INPUT),
10651         HDA_CODEC_MUTE("AUX IN Playback Switch", 0x0b, 0x06, HDA_INPUT),
10652         { } /* end */
10653 };
10654
10655 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_mixer[] = {
10656         ALC262_HP_MASTER_SWITCH,
10657         HDA_CODEC_VOLUME("Front Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10658         HDA_CODEC_MUTE("Front Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10659         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10660         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10661         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 2, 0x0,
10662                               HDA_OUTPUT),
10663         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 2, 0x0,
10664                             HDA_OUTPUT),
10665         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x02, HDA_INPUT),
10666         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x02, HDA_INPUT),
10667         HDA_CODEC_VOLUME("Front Mic Boost", 0x1a, 0, HDA_INPUT),
10668         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10669         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10670         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10671         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10672         { } /* end */
10673 };
10674
10675 static struct snd_kcontrol_new alc262_HP_BPC_WildWest_option_mixer[] = {
10676         HDA_CODEC_VOLUME("Rear Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10677         HDA_CODEC_MUTE("Rear Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10678         HDA_CODEC_VOLUME("Rear Mic Boost", 0x18, 0, HDA_INPUT),
10679         { } /* end */
10680 };
10681
10682 /* mute/unmute internal speaker according to the hp jack and mute state */
10683 static void alc262_hp_t5735_setup(struct hda_codec *codec)
10684 {
10685         struct alc_spec *spec = codec->spec;
10686
10687         spec->autocfg.hp_pins[0] = 0x15;
10688         spec->autocfg.speaker_pins[0] = 0x14;
10689 }
10690
10691 static struct snd_kcontrol_new alc262_hp_t5735_mixer[] = {
10692         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10693         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
10694         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10695         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10696         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10697         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10698         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10699         { } /* end */
10700 };
10701
10702 static struct hda_verb alc262_hp_t5735_verbs[] = {
10703         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10704         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10705
10706         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
10707         { }
10708 };
10709
10710 static struct snd_kcontrol_new alc262_hp_rp5700_mixer[] = {
10711         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10712         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
10713         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0e, 0x0, HDA_OUTPUT),
10714         HDA_CODEC_MUTE("Speaker Playback Switch", 0x16, 0x0, HDA_OUTPUT),
10715         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x01, HDA_INPUT),
10716         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x01, HDA_INPUT),
10717         { } /* end */
10718 };
10719
10720 static struct hda_verb alc262_hp_rp5700_verbs[] = {
10721         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10722         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
10723         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10724         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
10725         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10726         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
10727         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10728         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
10729         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10730         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x00 << 8))},
10731         {}
10732 };
10733
10734 static struct hda_input_mux alc262_hp_rp5700_capture_source = {
10735         .num_items = 1,
10736         .items = {
10737                 { "Line", 0x1 },
10738         },
10739 };
10740
10741 /* bind hp and internal speaker mute (with plug check) as master switch */
10742 static void alc262_hippo_master_update(struct hda_codec *codec)
10743 {
10744         struct alc_spec *spec = codec->spec;
10745         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10746         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
10747         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
10748         unsigned int mute;
10749
10750         /* HP */
10751         mute = spec->master_sw ? 0 : HDA_AMP_MUTE;
10752         snd_hda_codec_amp_stereo(codec, hp_nid, HDA_OUTPUT, 0,
10753                                  HDA_AMP_MUTE, mute);
10754         /* mute internal speaker per jack sense */
10755         if (spec->jack_present)
10756                 mute = HDA_AMP_MUTE;
10757         if (line_nid)
10758                 snd_hda_codec_amp_stereo(codec, line_nid, HDA_OUTPUT, 0,
10759                                          HDA_AMP_MUTE, mute);
10760         if (speaker_nid && speaker_nid != line_nid)
10761                 snd_hda_codec_amp_stereo(codec, speaker_nid, HDA_OUTPUT, 0,
10762                                          HDA_AMP_MUTE, mute);
10763 }
10764
10765 #define alc262_hippo_master_sw_get      alc262_hp_master_sw_get
10766
10767 static int alc262_hippo_master_sw_put(struct snd_kcontrol *kcontrol,
10768                                       struct snd_ctl_elem_value *ucontrol)
10769 {
10770         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
10771         struct alc_spec *spec = codec->spec;
10772         int val = !!*ucontrol->value.integer.value;
10773
10774         if (val == spec->master_sw)
10775                 return 0;
10776         spec->master_sw = val;
10777         alc262_hippo_master_update(codec);
10778         return 1;
10779 }
10780
10781 #define ALC262_HIPPO_MASTER_SWITCH                              \
10782         {                                                       \
10783                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,            \
10784                 .name = "Master Playback Switch",               \
10785                 .info = snd_ctl_boolean_mono_info,              \
10786                 .get = alc262_hippo_master_sw_get,              \
10787                 .put = alc262_hippo_master_sw_put,              \
10788         },                                                      \
10789         {                                                       \
10790                 .iface = NID_MAPPING,                           \
10791                 .name = "Master Playback Switch",               \
10792                 .subdevice = SUBDEV_HP(0) | (SUBDEV_LINE(0) << 8) | \
10793                              (SUBDEV_SPEAKER(0) << 16), \
10794         }
10795
10796 static struct snd_kcontrol_new alc262_hippo_mixer[] = {
10797         ALC262_HIPPO_MASTER_SWITCH,
10798         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10799         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10800         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10801         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10802         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10803         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10804         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10805         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10806         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10807         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10808         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10809         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
10810         { } /* end */
10811 };
10812
10813 static struct snd_kcontrol_new alc262_hippo1_mixer[] = {
10814         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10815         ALC262_HIPPO_MASTER_SWITCH,
10816         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
10817         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
10818         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10819         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10822         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10823         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10824         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10825         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10826         { } /* end */
10827 };
10828
10829 /* mute/unmute internal speaker according to the hp jack and mute state */
10830 static void alc262_hippo_automute(struct hda_codec *codec)
10831 {
10832         struct alc_spec *spec = codec->spec;
10833         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
10834
10835         spec->jack_present = snd_hda_jack_detect(codec, hp_nid);
10836         alc262_hippo_master_update(codec);
10837 }
10838
10839 static void alc262_hippo_unsol_event(struct hda_codec *codec, unsigned int res)
10840 {
10841         if ((res >> 26) != ALC880_HP_EVENT)
10842                 return;
10843         alc262_hippo_automute(codec);
10844 }
10845
10846 static void alc262_hippo_setup(struct hda_codec *codec)
10847 {
10848         struct alc_spec *spec = codec->spec;
10849
10850         spec->autocfg.hp_pins[0] = 0x15;
10851         spec->autocfg.speaker_pins[0] = 0x14;
10852 }
10853
10854 static void alc262_hippo1_setup(struct hda_codec *codec)
10855 {
10856         struct alc_spec *spec = codec->spec;
10857
10858         spec->autocfg.hp_pins[0] = 0x1b;
10859         spec->autocfg.speaker_pins[0] = 0x14;
10860 }
10861
10862
10863 static struct snd_kcontrol_new alc262_sony_mixer[] = {
10864         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10865         ALC262_HIPPO_MASTER_SWITCH,
10866         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10867         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10868         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10869         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10870         { } /* end */
10871 };
10872
10873 static struct snd_kcontrol_new alc262_benq_t31_mixer[] = {
10874         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10875         ALC262_HIPPO_MASTER_SWITCH,
10876         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
10877         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10878         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10879         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10880         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10881         { } /* end */
10882 };
10883
10884 static struct snd_kcontrol_new alc262_tyan_mixer[] = {
10885         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
10886         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
10887         HDA_CODEC_VOLUME("Aux Playback Volume", 0x0b, 0x06, HDA_INPUT),
10888         HDA_CODEC_MUTE("Aux Playback Switch", 0x0b, 0x06, HDA_INPUT),
10889         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
10890         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
10891         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
10892         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
10893         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
10894         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
10895         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
10896         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
10897         { } /* end */
10898 };
10899
10900 static struct hda_verb alc262_tyan_verbs[] = {
10901         /* Headphone automute */
10902         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
10903         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
10904         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
10905
10906         /* P11 AUX_IN, white 4-pin connector */
10907         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
10908         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_1, 0xe1},
10909         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_2, 0x93},
10910         {0x14, AC_VERB_SET_CONFIG_DEFAULT_BYTES_3, 0x19},
10911
10912         {}
10913 };
10914
10915 /* unsolicited event for HP jack sensing */
10916 static void alc262_tyan_setup(struct hda_codec *codec)
10917 {
10918         struct alc_spec *spec = codec->spec;
10919
10920         spec->autocfg.hp_pins[0] = 0x1b;
10921         spec->autocfg.speaker_pins[0] = 0x15;
10922 }
10923
10924
10925 #define alc262_capture_mixer            alc882_capture_mixer
10926 #define alc262_capture_alt_mixer        alc882_capture_alt_mixer
10927
10928 /*
10929  * generic initialization of ADC, input mixers and output mixers
10930  */
10931 static struct hda_verb alc262_init_verbs[] = {
10932         /*
10933          * Unmute ADC0-2 and set the default input to mic-in
10934          */
10935         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
10936         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10937         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
10938         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10939         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
10940         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10941
10942         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
10943          * mixer widget
10944          * Note: PASD motherboards uses the Line In 2 as the input for
10945          * front panel mic (mic 2)
10946          */
10947         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
10948         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
10949         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
10950         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
10951         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
10952         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
10953
10954         /*
10955          * Set up output mixers (0x0c - 0x0e)
10956          */
10957         /* set vol=0 to output mixers */
10958         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10959         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10960         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
10961         /* set up input amps for analog loopback */
10962         /* Amp Indices: DAC = 0, mixer = 1 */
10963         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10964         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10965         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10966         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10967         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
10968         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
10969
10970         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10971         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
10972         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
10973         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
10974         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10975         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
10976
10977         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10978         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10979         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10980         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10981         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
10982
10983         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
10984         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
10985
10986         /* FIXME: use matrix-type input source selection */
10987         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
10988         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
10989         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10990         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10991         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10992         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10993         /* Input mixer2 */
10994         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
10995         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
10996         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
10997         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
10998         /* Input mixer3 */
10999         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11000         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11001         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11002         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11003
11004         { }
11005 };
11006
11007 static struct hda_verb alc262_eapd_verbs[] = {
11008         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
11009         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
11010         { }
11011 };
11012
11013 static struct hda_verb alc262_hippo1_unsol_verbs[] = {
11014         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11015         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11016         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, 0x0000},
11017
11018         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11019         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11020         {}
11021 };
11022
11023 static struct hda_verb alc262_sony_unsol_verbs[] = {
11024         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
11025         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11026         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},   // Front Mic
11027
11028         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11029         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11030         {}
11031 };
11032
11033 static struct snd_kcontrol_new alc262_toshiba_s06_mixer[] = {
11034         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11035         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
11036         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11037         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11038         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11039         { } /* end */
11040 };
11041
11042 static struct hda_verb alc262_toshiba_s06_verbs[] = {
11043         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
11044         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11045         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11046         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11047         {0x22, AC_VERB_SET_CONNECT_SEL, 0x09},
11048         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11049         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
11050         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11051         {}
11052 };
11053
11054 static void alc262_toshiba_s06_setup(struct hda_codec *codec)
11055 {
11056         struct alc_spec *spec = codec->spec;
11057
11058         spec->autocfg.hp_pins[0] = 0x15;
11059         spec->autocfg.speaker_pins[0] = 0x14;
11060         spec->ext_mic.pin = 0x18;
11061         spec->ext_mic.mux_idx = 0;
11062         spec->int_mic.pin = 0x12;
11063         spec->int_mic.mux_idx = 9;
11064         spec->auto_mic = 1;
11065 }
11066
11067 /*
11068  * nec model
11069  *  0x15 = headphone
11070  *  0x16 = internal speaker
11071  *  0x18 = external mic
11072  */
11073
11074 static struct snd_kcontrol_new alc262_nec_mixer[] = {
11075         HDA_CODEC_VOLUME_MONO("Speaker Playback Volume", 0x0e, 1, 0x0, HDA_OUTPUT),
11076         HDA_CODEC_MUTE_MONO("Speaker Playback Switch", 0x16, 0, 0x0, HDA_OUTPUT),
11077
11078         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11079         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11080         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11081
11082         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x0d, 0x0, HDA_OUTPUT),
11083         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
11084         { } /* end */
11085 };
11086
11087 static struct hda_verb alc262_nec_verbs[] = {
11088         /* Unmute Speaker */
11089         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
11090
11091         /* Headphone */
11092         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11093         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11094
11095         /* External mic to headphone */
11096         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11097         /* External mic to speaker */
11098         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11099         {}
11100 };
11101
11102 /*
11103  * fujitsu model
11104  *  0x14 = headphone/spdif-out, 0x15 = internal speaker,
11105  *  0x1b = port replicator headphone out
11106  */
11107
11108 #define ALC_HP_EVENT    0x37
11109
11110 static struct hda_verb alc262_fujitsu_unsol_verbs[] = {
11111         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11112         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11113         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11114         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11115         {}
11116 };
11117
11118 static struct hda_verb alc262_lenovo_3000_unsol_verbs[] = {
11119         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC_HP_EVENT},
11120         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11121         {}
11122 };
11123
11124 static struct hda_verb alc262_lenovo_3000_init_verbs[] = {
11125         /* Front Mic pin: input vref at 50% */
11126         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
11127         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11128         {}
11129 };
11130
11131 static struct hda_input_mux alc262_fujitsu_capture_source = {
11132         .num_items = 3,
11133         .items = {
11134                 { "Mic", 0x0 },
11135                 { "Int Mic", 0x1 },
11136                 { "CD", 0x4 },
11137         },
11138 };
11139
11140 static struct hda_input_mux alc262_HP_capture_source = {
11141         .num_items = 5,
11142         .items = {
11143                 { "Mic", 0x0 },
11144                 { "Front Mic", 0x1 },
11145                 { "Line", 0x2 },
11146                 { "CD", 0x4 },
11147                 { "AUX IN", 0x6 },
11148         },
11149 };
11150
11151 static struct hda_input_mux alc262_HP_D7000_capture_source = {
11152         .num_items = 4,
11153         .items = {
11154                 { "Mic", 0x0 },
11155                 { "Front Mic", 0x2 },
11156                 { "Line", 0x1 },
11157                 { "CD", 0x4 },
11158         },
11159 };
11160
11161 /* mute/unmute internal speaker according to the hp jacks and mute state */
11162 static void alc262_fujitsu_automute(struct hda_codec *codec, int force)
11163 {
11164         struct alc_spec *spec = codec->spec;
11165         unsigned int mute;
11166
11167         if (force || !spec->sense_updated) {
11168                 spec->jack_present = snd_hda_jack_detect(codec, 0x14) ||
11169                                      snd_hda_jack_detect(codec, 0x1b);
11170                 spec->sense_updated = 1;
11171         }
11172         /* unmute internal speaker only if both HPs are unplugged and
11173          * master switch is on
11174          */
11175         if (spec->jack_present)
11176                 mute = HDA_AMP_MUTE;
11177         else
11178                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
11179         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11180                                  HDA_AMP_MUTE, mute);
11181 }
11182
11183 /* unsolicited event for HP jack sensing */
11184 static void alc262_fujitsu_unsol_event(struct hda_codec *codec,
11185                                        unsigned int res)
11186 {
11187         if ((res >> 26) != ALC_HP_EVENT)
11188                 return;
11189         alc262_fujitsu_automute(codec, 1);
11190 }
11191
11192 static void alc262_fujitsu_init_hook(struct hda_codec *codec)
11193 {
11194         alc262_fujitsu_automute(codec, 1);
11195 }
11196
11197 /* bind volumes of both NID 0x0c and 0x0d */
11198 static struct hda_bind_ctls alc262_fujitsu_bind_master_vol = {
11199         .ops = &snd_hda_bind_vol,
11200         .values = {
11201                 HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT),
11202                 HDA_COMPOSE_AMP_VAL(0x0d, 3, 0, HDA_OUTPUT),
11203                 0
11204         },
11205 };
11206
11207 /* mute/unmute internal speaker according to the hp jack and mute state */
11208 static void alc262_lenovo_3000_automute(struct hda_codec *codec, int force)
11209 {
11210         struct alc_spec *spec = codec->spec;
11211         unsigned int mute;
11212
11213         if (force || !spec->sense_updated) {
11214                 spec->jack_present = snd_hda_jack_detect(codec, 0x1b);
11215                 spec->sense_updated = 1;
11216         }
11217         if (spec->jack_present) {
11218                 /* mute internal speaker */
11219                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11220                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11221                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11222                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
11223         } else {
11224                 /* unmute internal speaker if necessary */
11225                 mute = snd_hda_codec_amp_read(codec, 0x1b, 0, HDA_OUTPUT, 0);
11226                 snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11227                                          HDA_AMP_MUTE, mute);
11228                 snd_hda_codec_amp_stereo(codec, 0x16, HDA_OUTPUT, 0,
11229                                          HDA_AMP_MUTE, mute);
11230         }
11231 }
11232
11233 /* unsolicited event for HP jack sensing */
11234 static void alc262_lenovo_3000_unsol_event(struct hda_codec *codec,
11235                                        unsigned int res)
11236 {
11237         if ((res >> 26) != ALC_HP_EVENT)
11238                 return;
11239         alc262_lenovo_3000_automute(codec, 1);
11240 }
11241
11242 static int amp_stereo_mute_update(struct hda_codec *codec, hda_nid_t nid,
11243                                   int dir, int idx, long *valp)
11244 {
11245         int i, change = 0;
11246
11247         for (i = 0; i < 2; i++, valp++)
11248                 change |= snd_hda_codec_amp_update(codec, nid, i, dir, idx,
11249                                                    HDA_AMP_MUTE,
11250                                                    *valp ? 0 : HDA_AMP_MUTE);
11251         return change;
11252 }
11253
11254 /* bind hp and internal speaker mute (with plug check) */
11255 static int alc262_fujitsu_master_sw_put(struct snd_kcontrol *kcontrol,
11256                                          struct snd_ctl_elem_value *ucontrol)
11257 {
11258         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11259         long *valp = ucontrol->value.integer.value;
11260         int change;
11261
11262         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
11263         change |= amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11264         if (change)
11265                 alc262_fujitsu_automute(codec, 0);
11266         return change;
11267 }
11268
11269 static struct snd_kcontrol_new alc262_fujitsu_mixer[] = {
11270         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11271         {
11272                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11273                 .name = "Master Playback Switch",
11274                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11275                 .info = snd_hda_mixer_amp_switch_info,
11276                 .get = snd_hda_mixer_amp_switch_get,
11277                 .put = alc262_fujitsu_master_sw_put,
11278                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
11279         },
11280         {
11281                 .iface = NID_MAPPING,
11282                 .name = "Master Playback Switch",
11283                 .private_value = 0x1b,
11284         },
11285         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11286         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11287         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11288         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11289         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11290         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11291         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11292         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11293         { } /* end */
11294 };
11295
11296 /* bind hp and internal speaker mute (with plug check) */
11297 static int alc262_lenovo_3000_master_sw_put(struct snd_kcontrol *kcontrol,
11298                                          struct snd_ctl_elem_value *ucontrol)
11299 {
11300         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11301         long *valp = ucontrol->value.integer.value;
11302         int change;
11303
11304         change = amp_stereo_mute_update(codec, 0x1b, HDA_OUTPUT, 0, valp);
11305         if (change)
11306                 alc262_lenovo_3000_automute(codec, 0);
11307         return change;
11308 }
11309
11310 static struct snd_kcontrol_new alc262_lenovo_3000_mixer[] = {
11311         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11312         {
11313                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11314                 .name = "Master Playback Switch",
11315                 .subdevice = HDA_SUBDEV_AMP_FLAG,
11316                 .info = snd_hda_mixer_amp_switch_info,
11317                 .get = snd_hda_mixer_amp_switch_get,
11318                 .put = alc262_lenovo_3000_master_sw_put,
11319                 .private_value = HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
11320         },
11321         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
11322         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
11323         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11324         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11325         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11326         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
11327         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
11328         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
11329         { } /* end */
11330 };
11331
11332 static struct snd_kcontrol_new alc262_toshiba_rx1_mixer[] = {
11333         HDA_BIND_VOL("Master Playback Volume", &alc262_fujitsu_bind_master_vol),
11334         ALC262_HIPPO_MASTER_SWITCH,
11335         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
11336         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
11337         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
11338         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11339         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11340         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
11341         { } /* end */
11342 };
11343
11344 /* additional init verbs for Benq laptops */
11345 static struct hda_verb alc262_EAPD_verbs[] = {
11346         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11347         {0x20, AC_VERB_SET_PROC_COEF,  0x3070},
11348         {}
11349 };
11350
11351 static struct hda_verb alc262_benq_t31_EAPD_verbs[] = {
11352         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11353         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11354
11355         {0x20, AC_VERB_SET_COEF_INDEX, 0x07},
11356         {0x20, AC_VERB_SET_PROC_COEF,  0x3050},
11357         {}
11358 };
11359
11360 /* Samsung Q1 Ultra Vista model setup */
11361 static struct snd_kcontrol_new alc262_ultra_mixer[] = {
11362         HDA_CODEC_VOLUME("Master Playback Volume", 0x0c, 0x0, HDA_OUTPUT),
11363         HDA_BIND_MUTE("Master Playback Switch", 0x0c, 2, HDA_INPUT),
11364         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
11365         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
11366         HDA_CODEC_VOLUME("Mic Boost", 0x19, 0, HDA_INPUT),
11367         HDA_CODEC_VOLUME("Headphone Mic Boost", 0x15, 0, HDA_INPUT),
11368         { } /* end */
11369 };
11370
11371 static struct hda_verb alc262_ultra_verbs[] = {
11372         /* output mixer */
11373         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11374         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11375         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11376         /* speaker */
11377         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
11378         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11379         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11380         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
11381         /* HP */
11382         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11383         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
11384         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11385         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11386         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11387         /* internal mic */
11388         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
11389         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11390         /* ADC, choose mic */
11391         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11392         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11393         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11394         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11395         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11396         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11397         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11398         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11399         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11400         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(8)},
11401         {}
11402 };
11403
11404 /* mute/unmute internal speaker according to the hp jack and mute state */
11405 static void alc262_ultra_automute(struct hda_codec *codec)
11406 {
11407         struct alc_spec *spec = codec->spec;
11408         unsigned int mute;
11409
11410         mute = 0;
11411         /* auto-mute only when HP is used as HP */
11412         if (!spec->cur_mux[0]) {
11413                 spec->jack_present = snd_hda_jack_detect(codec, 0x15);
11414                 if (spec->jack_present)
11415                         mute = HDA_AMP_MUTE;
11416         }
11417         /* mute/unmute internal speaker */
11418         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
11419                                  HDA_AMP_MUTE, mute);
11420         /* mute/unmute HP */
11421         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
11422                                  HDA_AMP_MUTE, mute ? 0 : HDA_AMP_MUTE);
11423 }
11424
11425 /* unsolicited event for HP jack sensing */
11426 static void alc262_ultra_unsol_event(struct hda_codec *codec,
11427                                        unsigned int res)
11428 {
11429         if ((res >> 26) != ALC880_HP_EVENT)
11430                 return;
11431         alc262_ultra_automute(codec);
11432 }
11433
11434 static struct hda_input_mux alc262_ultra_capture_source = {
11435         .num_items = 2,
11436         .items = {
11437                 { "Mic", 0x1 },
11438                 { "Headphone", 0x7 },
11439         },
11440 };
11441
11442 static int alc262_ultra_mux_enum_put(struct snd_kcontrol *kcontrol,
11443                                      struct snd_ctl_elem_value *ucontrol)
11444 {
11445         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
11446         struct alc_spec *spec = codec->spec;
11447         int ret;
11448
11449         ret = alc_mux_enum_put(kcontrol, ucontrol);
11450         if (!ret)
11451                 return 0;
11452         /* reprogram the HP pin as mic or HP according to the input source */
11453         snd_hda_codec_write_cache(codec, 0x15, 0,
11454                                   AC_VERB_SET_PIN_WIDGET_CONTROL,
11455                                   spec->cur_mux[0] ? PIN_VREF80 : PIN_HP);
11456         alc262_ultra_automute(codec); /* mute/unmute HP */
11457         return ret;
11458 }
11459
11460 static struct snd_kcontrol_new alc262_ultra_capture_mixer[] = {
11461         HDA_CODEC_VOLUME("Capture Volume", 0x07, 0x0, HDA_INPUT),
11462         HDA_CODEC_MUTE("Capture Switch", 0x07, 0x0, HDA_INPUT),
11463         {
11464                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
11465                 .name = "Capture Source",
11466                 .info = alc_mux_enum_info,
11467                 .get = alc_mux_enum_get,
11468                 .put = alc262_ultra_mux_enum_put,
11469         },
11470         {
11471                 .iface = NID_MAPPING,
11472                 .name = "Capture Source",
11473                 .private_value = 0x15,
11474         },
11475         { } /* end */
11476 };
11477
11478 /* We use two mixers depending on the output pin; 0x16 is a mono output
11479  * and thus it's bound with a different mixer.
11480  * This function returns which mixer amp should be used.
11481  */
11482 static int alc262_check_volbit(hda_nid_t nid)
11483 {
11484         if (!nid)
11485                 return 0;
11486         else if (nid == 0x16)
11487                 return 2;
11488         else
11489                 return 1;
11490 }
11491
11492 static int alc262_add_out_vol_ctl(struct alc_spec *spec, hda_nid_t nid,
11493                                   const char *pfx, int *vbits)
11494 {
11495         unsigned long val;
11496         int vbit;
11497
11498         vbit = alc262_check_volbit(nid);
11499         if (!vbit)
11500                 return 0;
11501         if (*vbits & vbit) /* a volume control for this mixer already there */
11502                 return 0;
11503         *vbits |= vbit;
11504         if (vbit == 2)
11505                 val = HDA_COMPOSE_AMP_VAL(0x0e, 2, 0, HDA_OUTPUT);
11506         else
11507                 val = HDA_COMPOSE_AMP_VAL(0x0c, 3, 0, HDA_OUTPUT);
11508         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx, val);
11509 }
11510
11511 static int alc262_add_out_sw_ctl(struct alc_spec *spec, hda_nid_t nid,
11512                                  const char *pfx)
11513 {
11514         unsigned long val;
11515
11516         if (!nid)
11517                 return 0;
11518         if (nid == 0x16)
11519                 val = HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT);
11520         else
11521                 val = HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_OUTPUT);
11522         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx, val);
11523 }
11524
11525 /* add playback controls from the parsed DAC table */
11526 static int alc262_auto_create_multi_out_ctls(struct alc_spec *spec,
11527                                              const struct auto_pin_cfg *cfg)
11528 {
11529         const char *pfx;
11530         int vbits;
11531         int err;
11532
11533         spec->multiout.num_dacs = 1;    /* only use one dac */
11534         spec->multiout.dac_nids = spec->private_dac_nids;
11535         spec->multiout.dac_nids[0] = 2;
11536
11537         if (!cfg->speaker_pins[0] && !cfg->hp_pins[0])
11538                 pfx = "Master";
11539         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11540                 pfx = "Speaker";
11541         else
11542                 pfx = "Front";
11543         err = alc262_add_out_sw_ctl(spec, cfg->line_out_pins[0], pfx);
11544         if (err < 0)
11545                 return err;
11546         err = alc262_add_out_sw_ctl(spec, cfg->speaker_pins[0], "Speaker");
11547         if (err < 0)
11548                 return err;
11549         err = alc262_add_out_sw_ctl(spec, cfg->hp_pins[0], "Headphone");
11550         if (err < 0)
11551                 return err;
11552
11553         vbits = alc262_check_volbit(cfg->line_out_pins[0]) |
11554                 alc262_check_volbit(cfg->speaker_pins[0]) |
11555                 alc262_check_volbit(cfg->hp_pins[0]);
11556         if (vbits == 1 || vbits == 2)
11557                 pfx = "Master"; /* only one mixer is used */
11558         else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
11559                 pfx = "Speaker";
11560         else
11561                 pfx = "Front";
11562         vbits = 0;
11563         err = alc262_add_out_vol_ctl(spec, cfg->line_out_pins[0], pfx, &vbits);
11564         if (err < 0)
11565                 return err;
11566         err = alc262_add_out_vol_ctl(spec, cfg->speaker_pins[0], "Speaker",
11567                                      &vbits);
11568         if (err < 0)
11569                 return err;
11570         err = alc262_add_out_vol_ctl(spec, cfg->hp_pins[0], "Headphone",
11571                                      &vbits);
11572         if (err < 0)
11573                 return err;
11574         return 0;
11575 }
11576
11577 #define alc262_auto_create_input_ctls \
11578         alc882_auto_create_input_ctls
11579
11580 /*
11581  * generic initialization of ADC, input mixers and output mixers
11582  */
11583 static struct hda_verb alc262_volume_init_verbs[] = {
11584         /*
11585          * Unmute ADC0-2 and set the default input to mic-in
11586          */
11587         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11588         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11589         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11590         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11591         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11592         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11593
11594         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11595          * mixer widget
11596          * Note: PASD motherboards uses the Line In 2 as the input for
11597          * front panel mic (mic 2)
11598          */
11599         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11600         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11601         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11602         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11603         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11604         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11605
11606         /*
11607          * Set up output mixers (0x0c - 0x0f)
11608          */
11609         /* set vol=0 to output mixers */
11610         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11611         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11612         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11613
11614         /* set up input amps for analog loopback */
11615         /* Amp Indices: DAC = 0, mixer = 1 */
11616         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11617         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11618         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11619         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11620         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11621         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11622
11623         /* FIXME: use matrix-type input source selection */
11624         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11625         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11626         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11627         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11628         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11629         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11630         /* Input mixer2 */
11631         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11632         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11633         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11634         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11635         /* Input mixer3 */
11636         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11637         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11638         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11639         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11640
11641         { }
11642 };
11643
11644 static struct hda_verb alc262_HP_BPC_init_verbs[] = {
11645         /*
11646          * Unmute ADC0-2 and set the default input to mic-in
11647          */
11648         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11649         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11650         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11651         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11652         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11653         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11654
11655         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11656          * mixer widget
11657          * Note: PASD motherboards uses the Line In 2 as the input for
11658          * front panel mic (mic 2)
11659          */
11660         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11661         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11662         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11663         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11664         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11665         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11666         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11667         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11668
11669         /*
11670          * Set up output mixers (0x0c - 0x0e)
11671          */
11672         /* set vol=0 to output mixers */
11673         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11674         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11675         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11676
11677         /* set up input amps for analog loopback */
11678         /* Amp Indices: DAC = 0, mixer = 1 */
11679         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11680         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11681         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11682         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11683         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11684         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11685
11686         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
11687         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11688         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
11689
11690         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11691         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11692
11693         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11694         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11695
11696         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11697         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11698         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
11699         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11700         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
11701
11702         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11703         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11704         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11705         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11706         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11707         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11708
11709
11710         /* FIXME: use matrix-type input source selection */
11711         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 0b, 12 */
11712         /* Input mixer1: only unmute Mic */
11713         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11714         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11715         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11716         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11717         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11718         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11719         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11720         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11721         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11722         /* Input mixer2 */
11723         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11724         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11725         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11726         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11727         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11728         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11729         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11730         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11731         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11732         /* Input mixer3 */
11733         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11734         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8))},
11735         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8))},
11736         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x03 << 8))},
11737         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x04 << 8))},
11738         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x05 << 8))},
11739         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x06 << 8))},
11740         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x07 << 8))},
11741         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x08 << 8))},
11742
11743         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11744
11745         { }
11746 };
11747
11748 static struct hda_verb alc262_HP_BPC_WildWest_init_verbs[] = {
11749         /*
11750          * Unmute ADC0-2 and set the default input to mic-in
11751          */
11752         {0x07, AC_VERB_SET_CONNECT_SEL, 0x00},
11753         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11754         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
11755         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11756         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
11757         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11758
11759         /* Mute input amps (CD, Line In, Mic 1 & Mic 2) of the analog-loopback
11760          * mixer widget
11761          * Note: PASD motherboards uses the Line In 2 as the input for front
11762          * panel mic (mic 2)
11763          */
11764         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
11765         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
11766         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
11767         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
11768         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
11769         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
11770         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
11771         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(6)},
11772         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(7)},
11773         /*
11774          * Set up output mixers (0x0c - 0x0e)
11775          */
11776         /* set vol=0 to output mixers */
11777         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11778         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11779         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
11780
11781         /* set up input amps for analog loopback */
11782         /* Amp Indices: DAC = 0, mixer = 1 */
11783         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11784         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11785         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11786         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11787         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
11788         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
11789
11790
11791         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP */
11792         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Mono */
11793         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* rear MIC */
11794         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* Line in */
11795         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11796         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Line out */
11797         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },        /* CD in */
11798
11799         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11801
11802         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
11803         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
11804
11805         /* {0x14, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 }, */
11806         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11807         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11808         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, 0x7023 },
11809         {0x1c, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11810         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, 0x7000 },
11811
11812         /* FIXME: use matrix-type input source selection */
11813         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
11814         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
11815         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))}, /*rear MIC*/
11816         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))}, /*Line in*/
11817         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))}, /*F MIC*/
11818         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))}, /*Front*/
11819         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))}, /*CD*/
11820         /* {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))},  */
11821         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))}, /*HP*/
11822         /* Input mixer2 */
11823         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11824         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11825         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11826         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11827         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11828         /* {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11829         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11830         /* Input mixer3 */
11831         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x00 << 8))},
11832         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8))},
11833         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8))},
11834         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x03 << 8))},
11835         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x04 << 8))},
11836         /* {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x06 << 8))}, */
11837         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x07 << 8))},
11838
11839         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
11840
11841         { }
11842 };
11843
11844 static struct hda_verb alc262_toshiba_rx1_unsol_verbs[] = {
11845
11846         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },       /* Front Speaker */
11847         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
11848         {0x14, AC_VERB_SET_CONNECT_SEL, 0x01},
11849
11850         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* MIC jack */
11851         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },    /* Front MIC */
11852         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11853         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0) },
11854
11855         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP },        /* HP  jack */
11856         {0x15, AC_VERB_SET_CONNECT_SEL, 0x00},
11857         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
11858         {}
11859 };
11860
11861
11862 #ifdef CONFIG_SND_HDA_POWER_SAVE
11863 #define alc262_loopbacks        alc880_loopbacks
11864 #endif
11865
11866 /* pcm configuration: identical with ALC880 */
11867 #define alc262_pcm_analog_playback      alc880_pcm_analog_playback
11868 #define alc262_pcm_analog_capture       alc880_pcm_analog_capture
11869 #define alc262_pcm_digital_playback     alc880_pcm_digital_playback
11870 #define alc262_pcm_digital_capture      alc880_pcm_digital_capture
11871
11872 /*
11873  * BIOS auto configuration
11874  */
11875 static int alc262_parse_auto_config(struct hda_codec *codec)
11876 {
11877         struct alc_spec *spec = codec->spec;
11878         int err;
11879         static hda_nid_t alc262_ignore[] = { 0x1d, 0 };
11880
11881         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
11882                                            alc262_ignore);
11883         if (err < 0)
11884                 return err;
11885         if (!spec->autocfg.line_outs) {
11886                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
11887                         spec->multiout.max_channels = 2;
11888                         spec->no_analog = 1;
11889                         goto dig_only;
11890                 }
11891                 return 0; /* can't find valid BIOS pin config */
11892         }
11893         err = alc262_auto_create_multi_out_ctls(spec, &spec->autocfg);
11894         if (err < 0)
11895                 return err;
11896         err = alc262_auto_create_input_ctls(codec, &spec->autocfg);
11897         if (err < 0)
11898                 return err;
11899
11900         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
11901
11902  dig_only:
11903         if (spec->autocfg.dig_outs) {
11904                 spec->multiout.dig_out_nid = ALC262_DIGOUT_NID;
11905                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
11906         }
11907         if (spec->autocfg.dig_in_pin)
11908                 spec->dig_in_nid = ALC262_DIGIN_NID;
11909
11910         if (spec->kctls.list)
11911                 add_mixer(spec, spec->kctls.list);
11912
11913         add_verb(spec, alc262_volume_init_verbs);
11914         spec->num_mux_defs = 1;
11915         spec->input_mux = &spec->private_imux[0];
11916
11917         err = alc_auto_add_mic_boost(codec);
11918         if (err < 0)
11919                 return err;
11920
11921         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
11922
11923         return 1;
11924 }
11925
11926 #define alc262_auto_init_multi_out      alc882_auto_init_multi_out
11927 #define alc262_auto_init_hp_out         alc882_auto_init_hp_out
11928 #define alc262_auto_init_analog_input   alc882_auto_init_analog_input
11929 #define alc262_auto_init_input_src      alc882_auto_init_input_src
11930
11931
11932 /* init callback for auto-configuration model -- overriding the default init */
11933 static void alc262_auto_init(struct hda_codec *codec)
11934 {
11935         struct alc_spec *spec = codec->spec;
11936         alc262_auto_init_multi_out(codec);
11937         alc262_auto_init_hp_out(codec);
11938         alc262_auto_init_analog_input(codec);
11939         alc262_auto_init_input_src(codec);
11940         if (spec->unsol_event)
11941                 alc_inithook(codec);
11942 }
11943
11944 /*
11945  * configuration and preset
11946  */
11947 static const char *alc262_models[ALC262_MODEL_LAST] = {
11948         [ALC262_BASIC]          = "basic",
11949         [ALC262_HIPPO]          = "hippo",
11950         [ALC262_HIPPO_1]        = "hippo_1",
11951         [ALC262_FUJITSU]        = "fujitsu",
11952         [ALC262_HP_BPC]         = "hp-bpc",
11953         [ALC262_HP_BPC_D7000_WL]= "hp-bpc-d7000",
11954         [ALC262_HP_TC_T5735]    = "hp-tc-t5735",
11955         [ALC262_HP_RP5700]      = "hp-rp5700",
11956         [ALC262_BENQ_ED8]       = "benq",
11957         [ALC262_BENQ_T31]       = "benq-t31",
11958         [ALC262_SONY_ASSAMD]    = "sony-assamd",
11959         [ALC262_TOSHIBA_S06]    = "toshiba-s06",
11960         [ALC262_TOSHIBA_RX1]    = "toshiba-rx1",
11961         [ALC262_ULTRA]          = "ultra",
11962         [ALC262_LENOVO_3000]    = "lenovo-3000",
11963         [ALC262_NEC]            = "nec",
11964         [ALC262_TYAN]           = "tyan",
11965         [ALC262_AUTO]           = "auto",
11966 };
11967
11968 static struct snd_pci_quirk alc262_cfg_tbl[] = {
11969         SND_PCI_QUIRK(0x1002, 0x437b, "Hippo", ALC262_HIPPO),
11970         SND_PCI_QUIRK(0x1033, 0x8895, "NEC Versa S9100", ALC262_NEC),
11971         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1200, "HP xw series",
11972                            ALC262_HP_BPC),
11973         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1300, "HP xw series",
11974                            ALC262_HP_BPC),
11975         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x1700, "HP xw series",
11976                            ALC262_HP_BPC),
11977         SND_PCI_QUIRK(0x103c, 0x2800, "HP D7000", ALC262_HP_BPC_D7000_WL),
11978         SND_PCI_QUIRK(0x103c, 0x2801, "HP D7000", ALC262_HP_BPC_D7000_WF),
11979         SND_PCI_QUIRK(0x103c, 0x2802, "HP D7000", ALC262_HP_BPC_D7000_WL),
11980         SND_PCI_QUIRK(0x103c, 0x2803, "HP D7000", ALC262_HP_BPC_D7000_WF),
11981         SND_PCI_QUIRK(0x103c, 0x2804, "HP D7000", ALC262_HP_BPC_D7000_WL),
11982         SND_PCI_QUIRK(0x103c, 0x2805, "HP D7000", ALC262_HP_BPC_D7000_WF),
11983         SND_PCI_QUIRK(0x103c, 0x2806, "HP D7000", ALC262_HP_BPC_D7000_WL),
11984         SND_PCI_QUIRK(0x103c, 0x2807, "HP D7000", ALC262_HP_BPC_D7000_WF),
11985         SND_PCI_QUIRK(0x103c, 0x280c, "HP xw4400", ALC262_HP_BPC),
11986         SND_PCI_QUIRK(0x103c, 0x3014, "HP xw6400", ALC262_HP_BPC),
11987         SND_PCI_QUIRK(0x103c, 0x3015, "HP xw8400", ALC262_HP_BPC),
11988         SND_PCI_QUIRK(0x103c, 0x302f, "HP Thin Client T5735",
11989                       ALC262_HP_TC_T5735),
11990         SND_PCI_QUIRK(0x103c, 0x2817, "HP RP5700", ALC262_HP_RP5700),
11991         SND_PCI_QUIRK(0x104d, 0x1f00, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11992         SND_PCI_QUIRK(0x104d, 0x8203, "Sony UX-90", ALC262_HIPPO),
11993         SND_PCI_QUIRK(0x104d, 0x820f, "Sony ASSAMD", ALC262_SONY_ASSAMD),
11994         SND_PCI_QUIRK(0x104d, 0x9016, "Sony VAIO", ALC262_AUTO), /* dig-only */
11995         SND_PCI_QUIRK(0x104d, 0x9025, "Sony VAIO Z21MN", ALC262_TOSHIBA_S06),
11996         SND_PCI_QUIRK(0x104d, 0x9035, "Sony VAIO VGN-FW170J", ALC262_AUTO),
11997         SND_PCI_QUIRK(0x104d, 0x9047, "Sony VAIO Type G", ALC262_AUTO),
11998 #if 0 /* disable the quirk since model=auto works better in recent versions */
11999         SND_PCI_QUIRK_MASK(0x104d, 0xff00, 0x9000, "Sony VAIO",
12000                            ALC262_SONY_ASSAMD),
12001 #endif
12002         SND_PCI_QUIRK(0x1179, 0x0001, "Toshiba dynabook SS RX1",
12003                       ALC262_TOSHIBA_RX1),
12004         SND_PCI_QUIRK(0x1179, 0xff7b, "Toshiba S06", ALC262_TOSHIBA_S06),
12005         SND_PCI_QUIRK(0x10cf, 0x1397, "Fujitsu", ALC262_FUJITSU),
12006         SND_PCI_QUIRK(0x10cf, 0x142d, "Fujitsu Lifebook E8410", ALC262_FUJITSU),
12007         SND_PCI_QUIRK(0x10f1, 0x2915, "Tyan Thunder n6650W", ALC262_TYAN),
12008         SND_PCI_QUIRK_MASK(0x144d, 0xff00, 0xc032, "Samsung Q1",
12009                            ALC262_ULTRA),
12010         SND_PCI_QUIRK(0x144d, 0xc510, "Samsung Q45", ALC262_HIPPO),
12011         SND_PCI_QUIRK(0x17aa, 0x384e, "Lenovo 3000 y410", ALC262_LENOVO_3000),
12012         SND_PCI_QUIRK(0x17ff, 0x0560, "Benq ED8", ALC262_BENQ_ED8),
12013         SND_PCI_QUIRK(0x17ff, 0x058d, "Benq T31-16", ALC262_BENQ_T31),
12014         SND_PCI_QUIRK(0x17ff, 0x058f, "Benq Hippo", ALC262_HIPPO_1),
12015         {}
12016 };
12017
12018 static struct alc_config_preset alc262_presets[] = {
12019         [ALC262_BASIC] = {
12020                 .mixers = { alc262_base_mixer },
12021                 .init_verbs = { alc262_init_verbs },
12022                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12023                 .dac_nids = alc262_dac_nids,
12024                 .hp_nid = 0x03,
12025                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12026                 .channel_mode = alc262_modes,
12027                 .input_mux = &alc262_capture_source,
12028         },
12029         [ALC262_HIPPO] = {
12030                 .mixers = { alc262_hippo_mixer },
12031                 .init_verbs = { alc262_init_verbs, alc_hp15_unsol_verbs},
12032                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12033                 .dac_nids = alc262_dac_nids,
12034                 .hp_nid = 0x03,
12035                 .dig_out_nid = ALC262_DIGOUT_NID,
12036                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12037                 .channel_mode = alc262_modes,
12038                 .input_mux = &alc262_capture_source,
12039                 .unsol_event = alc262_hippo_unsol_event,
12040                 .setup = alc262_hippo_setup,
12041                 .init_hook = alc262_hippo_automute,
12042         },
12043         [ALC262_HIPPO_1] = {
12044                 .mixers = { alc262_hippo1_mixer },
12045                 .init_verbs = { alc262_init_verbs, alc262_hippo1_unsol_verbs},
12046                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12047                 .dac_nids = alc262_dac_nids,
12048                 .hp_nid = 0x02,
12049                 .dig_out_nid = ALC262_DIGOUT_NID,
12050                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12051                 .channel_mode = alc262_modes,
12052                 .input_mux = &alc262_capture_source,
12053                 .unsol_event = alc262_hippo_unsol_event,
12054                 .setup = alc262_hippo1_setup,
12055                 .init_hook = alc262_hippo_automute,
12056         },
12057         [ALC262_FUJITSU] = {
12058                 .mixers = { alc262_fujitsu_mixer },
12059                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12060                                 alc262_fujitsu_unsol_verbs },
12061                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12062                 .dac_nids = alc262_dac_nids,
12063                 .hp_nid = 0x03,
12064                 .dig_out_nid = ALC262_DIGOUT_NID,
12065                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12066                 .channel_mode = alc262_modes,
12067                 .input_mux = &alc262_fujitsu_capture_source,
12068                 .unsol_event = alc262_fujitsu_unsol_event,
12069                 .init_hook = alc262_fujitsu_init_hook,
12070         },
12071         [ALC262_HP_BPC] = {
12072                 .mixers = { alc262_HP_BPC_mixer },
12073                 .init_verbs = { alc262_HP_BPC_init_verbs },
12074                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12075                 .dac_nids = alc262_dac_nids,
12076                 .hp_nid = 0x03,
12077                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12078                 .channel_mode = alc262_modes,
12079                 .input_mux = &alc262_HP_capture_source,
12080                 .unsol_event = alc262_hp_bpc_unsol_event,
12081                 .init_hook = alc262_hp_bpc_automute,
12082         },
12083         [ALC262_HP_BPC_D7000_WF] = {
12084                 .mixers = { alc262_HP_BPC_WildWest_mixer },
12085                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12086                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12087                 .dac_nids = alc262_dac_nids,
12088                 .hp_nid = 0x03,
12089                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12090                 .channel_mode = alc262_modes,
12091                 .input_mux = &alc262_HP_D7000_capture_source,
12092                 .unsol_event = alc262_hp_wildwest_unsol_event,
12093                 .init_hook = alc262_hp_wildwest_automute,
12094         },
12095         [ALC262_HP_BPC_D7000_WL] = {
12096                 .mixers = { alc262_HP_BPC_WildWest_mixer,
12097                             alc262_HP_BPC_WildWest_option_mixer },
12098                 .init_verbs = { alc262_HP_BPC_WildWest_init_verbs },
12099                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12100                 .dac_nids = alc262_dac_nids,
12101                 .hp_nid = 0x03,
12102                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12103                 .channel_mode = alc262_modes,
12104                 .input_mux = &alc262_HP_D7000_capture_source,
12105                 .unsol_event = alc262_hp_wildwest_unsol_event,
12106                 .init_hook = alc262_hp_wildwest_automute,
12107         },
12108         [ALC262_HP_TC_T5735] = {
12109                 .mixers = { alc262_hp_t5735_mixer },
12110                 .init_verbs = { alc262_init_verbs, alc262_hp_t5735_verbs },
12111                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12112                 .dac_nids = alc262_dac_nids,
12113                 .hp_nid = 0x03,
12114                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12115                 .channel_mode = alc262_modes,
12116                 .input_mux = &alc262_capture_source,
12117                 .unsol_event = alc_sku_unsol_event,
12118                 .setup = alc262_hp_t5735_setup,
12119                 .init_hook = alc_inithook,
12120         },
12121         [ALC262_HP_RP5700] = {
12122                 .mixers = { alc262_hp_rp5700_mixer },
12123                 .init_verbs = { alc262_init_verbs, alc262_hp_rp5700_verbs },
12124                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12125                 .dac_nids = alc262_dac_nids,
12126                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12127                 .channel_mode = alc262_modes,
12128                 .input_mux = &alc262_hp_rp5700_capture_source,
12129         },
12130         [ALC262_BENQ_ED8] = {
12131                 .mixers = { alc262_base_mixer },
12132                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs },
12133                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12134                 .dac_nids = alc262_dac_nids,
12135                 .hp_nid = 0x03,
12136                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12137                 .channel_mode = alc262_modes,
12138                 .input_mux = &alc262_capture_source,
12139         },
12140         [ALC262_SONY_ASSAMD] = {
12141                 .mixers = { alc262_sony_mixer },
12142                 .init_verbs = { alc262_init_verbs, alc262_sony_unsol_verbs},
12143                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12144                 .dac_nids = alc262_dac_nids,
12145                 .hp_nid = 0x02,
12146                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12147                 .channel_mode = alc262_modes,
12148                 .input_mux = &alc262_capture_source,
12149                 .unsol_event = alc262_hippo_unsol_event,
12150                 .setup = alc262_hippo_setup,
12151                 .init_hook = alc262_hippo_automute,
12152         },
12153         [ALC262_BENQ_T31] = {
12154                 .mixers = { alc262_benq_t31_mixer },
12155                 .init_verbs = { alc262_init_verbs, alc262_benq_t31_EAPD_verbs,
12156                                 alc_hp15_unsol_verbs },
12157                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12158                 .dac_nids = alc262_dac_nids,
12159                 .hp_nid = 0x03,
12160                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12161                 .channel_mode = alc262_modes,
12162                 .input_mux = &alc262_capture_source,
12163                 .unsol_event = alc262_hippo_unsol_event,
12164                 .setup = alc262_hippo_setup,
12165                 .init_hook = alc262_hippo_automute,
12166         },
12167         [ALC262_ULTRA] = {
12168                 .mixers = { alc262_ultra_mixer },
12169                 .cap_mixer = alc262_ultra_capture_mixer,
12170                 .init_verbs = { alc262_ultra_verbs },
12171                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12172                 .dac_nids = alc262_dac_nids,
12173                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12174                 .channel_mode = alc262_modes,
12175                 .input_mux = &alc262_ultra_capture_source,
12176                 .adc_nids = alc262_adc_nids, /* ADC0 */
12177                 .capsrc_nids = alc262_capsrc_nids,
12178                 .num_adc_nids = 1, /* single ADC */
12179                 .unsol_event = alc262_ultra_unsol_event,
12180                 .init_hook = alc262_ultra_automute,
12181         },
12182         [ALC262_LENOVO_3000] = {
12183                 .mixers = { alc262_lenovo_3000_mixer },
12184                 .init_verbs = { alc262_init_verbs, alc262_EAPD_verbs,
12185                                 alc262_lenovo_3000_unsol_verbs,
12186                                 alc262_lenovo_3000_init_verbs },
12187                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12188                 .dac_nids = alc262_dac_nids,
12189                 .hp_nid = 0x03,
12190                 .dig_out_nid = ALC262_DIGOUT_NID,
12191                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12192                 .channel_mode = alc262_modes,
12193                 .input_mux = &alc262_fujitsu_capture_source,
12194                 .unsol_event = alc262_lenovo_3000_unsol_event,
12195         },
12196         [ALC262_NEC] = {
12197                 .mixers = { alc262_nec_mixer },
12198                 .init_verbs = { alc262_nec_verbs },
12199                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12200                 .dac_nids = alc262_dac_nids,
12201                 .hp_nid = 0x03,
12202                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12203                 .channel_mode = alc262_modes,
12204                 .input_mux = &alc262_capture_source,
12205         },
12206         [ALC262_TOSHIBA_S06] = {
12207                 .mixers = { alc262_toshiba_s06_mixer },
12208                 .init_verbs = { alc262_init_verbs, alc262_toshiba_s06_verbs,
12209                                                         alc262_eapd_verbs },
12210                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12211                 .capsrc_nids = alc262_dmic_capsrc_nids,
12212                 .dac_nids = alc262_dac_nids,
12213                 .adc_nids = alc262_dmic_adc_nids, /* ADC0 */
12214                 .num_adc_nids = 1, /* single ADC */
12215                 .dig_out_nid = ALC262_DIGOUT_NID,
12216                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12217                 .channel_mode = alc262_modes,
12218                 .unsol_event = alc_sku_unsol_event,
12219                 .setup = alc262_toshiba_s06_setup,
12220                 .init_hook = alc_inithook,
12221         },
12222         [ALC262_TOSHIBA_RX1] = {
12223                 .mixers = { alc262_toshiba_rx1_mixer },
12224                 .init_verbs = { alc262_init_verbs, alc262_toshiba_rx1_unsol_verbs },
12225                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12226                 .dac_nids = alc262_dac_nids,
12227                 .hp_nid = 0x03,
12228                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12229                 .channel_mode = alc262_modes,
12230                 .input_mux = &alc262_capture_source,
12231                 .unsol_event = alc262_hippo_unsol_event,
12232                 .setup = alc262_hippo_setup,
12233                 .init_hook = alc262_hippo_automute,
12234         },
12235         [ALC262_TYAN] = {
12236                 .mixers = { alc262_tyan_mixer },
12237                 .init_verbs = { alc262_init_verbs, alc262_tyan_verbs},
12238                 .num_dacs = ARRAY_SIZE(alc262_dac_nids),
12239                 .dac_nids = alc262_dac_nids,
12240                 .hp_nid = 0x02,
12241                 .dig_out_nid = ALC262_DIGOUT_NID,
12242                 .num_channel_mode = ARRAY_SIZE(alc262_modes),
12243                 .channel_mode = alc262_modes,
12244                 .input_mux = &alc262_capture_source,
12245                 .unsol_event = alc_automute_amp_unsol_event,
12246                 .setup = alc262_tyan_setup,
12247                 .init_hook = alc_automute_amp,
12248         },
12249 };
12250
12251 static int patch_alc262(struct hda_codec *codec)
12252 {
12253         struct alc_spec *spec;
12254         int board_config;
12255         int err;
12256
12257         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
12258         if (spec == NULL)
12259                 return -ENOMEM;
12260
12261         codec->spec = spec;
12262 #if 0
12263         /* pshou 07/11/05  set a zero PCM sample to DAC when FIFO is
12264          * under-run
12265          */
12266         {
12267         int tmp;
12268         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12269         tmp = snd_hda_codec_read(codec, 0x20, 0, AC_VERB_GET_PROC_COEF, 0);
12270         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_COEF_INDEX, 7);
12271         snd_hda_codec_write(codec, 0x1a, 0, AC_VERB_SET_PROC_COEF, tmp | 0x80);
12272         }
12273 #endif
12274
12275         alc_fix_pll_init(codec, 0x20, 0x0a, 10);
12276
12277         board_config = snd_hda_check_board_config(codec, ALC262_MODEL_LAST,
12278                                                   alc262_models,
12279                                                   alc262_cfg_tbl);
12280
12281         if (board_config < 0) {
12282                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
12283                        codec->chip_name);
12284                 board_config = ALC262_AUTO;
12285         }
12286
12287         if (board_config == ALC262_AUTO) {
12288                 /* automatic parse from the BIOS config */
12289                 err = alc262_parse_auto_config(codec);
12290                 if (err < 0) {
12291                         alc_free(codec);
12292                         return err;
12293                 } else if (!err) {
12294                         printk(KERN_INFO
12295                                "hda_codec: Cannot set up configuration "
12296                                "from BIOS.  Using base mode...\n");
12297                         board_config = ALC262_BASIC;
12298                 }
12299         }
12300
12301         if (!spec->no_analog) {
12302                 err = snd_hda_attach_beep_device(codec, 0x1);
12303                 if (err < 0) {
12304                         alc_free(codec);
12305                         return err;
12306                 }
12307         }
12308
12309         if (board_config != ALC262_AUTO)
12310                 setup_preset(codec, &alc262_presets[board_config]);
12311
12312         spec->stream_analog_playback = &alc262_pcm_analog_playback;
12313         spec->stream_analog_capture = &alc262_pcm_analog_capture;
12314
12315         spec->stream_digital_playback = &alc262_pcm_digital_playback;
12316         spec->stream_digital_capture = &alc262_pcm_digital_capture;
12317
12318         if (!spec->adc_nids && spec->input_mux) {
12319                 int i;
12320                 /* check whether the digital-mic has to be supported */
12321                 for (i = 0; i < spec->input_mux->num_items; i++) {
12322                         if (spec->input_mux->items[i].index >= 9)
12323                                 break;
12324                 }
12325                 if (i < spec->input_mux->num_items) {
12326                         /* use only ADC0 */
12327                         spec->adc_nids = alc262_dmic_adc_nids;
12328                         spec->num_adc_nids = 1;
12329                         spec->capsrc_nids = alc262_dmic_capsrc_nids;
12330                 } else {
12331                         /* all analog inputs */
12332                         /* check whether NID 0x07 is valid */
12333                         unsigned int wcap = get_wcaps(codec, 0x07);
12334
12335                         /* get type */
12336                         wcap = get_wcaps_type(wcap);
12337                         if (wcap != AC_WID_AUD_IN) {
12338                                 spec->adc_nids = alc262_adc_nids_alt;
12339                                 spec->num_adc_nids =
12340                                         ARRAY_SIZE(alc262_adc_nids_alt);
12341                                 spec->capsrc_nids = alc262_capsrc_nids_alt;
12342                         } else {
12343                                 spec->adc_nids = alc262_adc_nids;
12344                                 spec->num_adc_nids =
12345                                         ARRAY_SIZE(alc262_adc_nids);
12346                                 spec->capsrc_nids = alc262_capsrc_nids;
12347                         }
12348                 }
12349         }
12350         if (!spec->cap_mixer && !spec->no_analog)
12351                 set_capture_mixer(codec);
12352         if (!spec->no_analog)
12353                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
12354
12355         spec->vmaster_nid = 0x0c;
12356
12357         codec->patch_ops = alc_patch_ops;
12358         if (board_config == ALC262_AUTO)
12359                 spec->init_hook = alc262_auto_init;
12360 #ifdef CONFIG_SND_HDA_POWER_SAVE
12361         if (!spec->loopback.amplist)
12362                 spec->loopback.amplist = alc262_loopbacks;
12363 #endif
12364
12365         return 0;
12366 }
12367
12368 /*
12369  *  ALC268 channel source setting (2 channel)
12370  */
12371 #define ALC268_DIGOUT_NID       ALC880_DIGOUT_NID
12372 #define alc268_modes            alc260_modes
12373
12374 static hda_nid_t alc268_dac_nids[2] = {
12375         /* front, hp */
12376         0x02, 0x03
12377 };
12378
12379 static hda_nid_t alc268_adc_nids[2] = {
12380         /* ADC0-1 */
12381         0x08, 0x07
12382 };
12383
12384 static hda_nid_t alc268_adc_nids_alt[1] = {
12385         /* ADC0 */
12386         0x08
12387 };
12388
12389 static hda_nid_t alc268_capsrc_nids[2] = { 0x23, 0x24 };
12390
12391 static struct snd_kcontrol_new alc268_base_mixer[] = {
12392         /* output mixer control */
12393         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12394         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12395         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12396         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12397         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12398         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12399         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12400         { }
12401 };
12402
12403 static struct snd_kcontrol_new alc268_toshiba_mixer[] = {
12404         /* output mixer control */
12405         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12406         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12407         ALC262_HIPPO_MASTER_SWITCH,
12408         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12409         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
12410         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12411         { }
12412 };
12413
12414 /* bind Beep switches of both NID 0x0f and 0x10 */
12415 static struct hda_bind_ctls alc268_bind_beep_sw = {
12416         .ops = &snd_hda_bind_sw,
12417         .values = {
12418                 HDA_COMPOSE_AMP_VAL(0x0f, 3, 1, HDA_INPUT),
12419                 HDA_COMPOSE_AMP_VAL(0x10, 3, 1, HDA_INPUT),
12420                 0
12421         },
12422 };
12423
12424 static struct snd_kcontrol_new alc268_beep_mixer[] = {
12425         HDA_CODEC_VOLUME("Beep Playback Volume", 0x1d, 0x0, HDA_INPUT),
12426         HDA_BIND_SW("Beep Playback Switch", &alc268_bind_beep_sw),
12427         { }
12428 };
12429
12430 static struct hda_verb alc268_eapd_verbs[] = {
12431         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
12432         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
12433         { }
12434 };
12435
12436 /* Toshiba specific */
12437 static struct hda_verb alc268_toshiba_verbs[] = {
12438         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12439         { } /* end */
12440 };
12441
12442 /* Acer specific */
12443 /* bind volumes of both NID 0x02 and 0x03 */
12444 static struct hda_bind_ctls alc268_acer_bind_master_vol = {
12445         .ops = &snd_hda_bind_vol,
12446         .values = {
12447                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
12448                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
12449                 0
12450         },
12451 };
12452
12453 /* mute/unmute internal speaker according to the hp jack and mute state */
12454 static void alc268_acer_automute(struct hda_codec *codec, int force)
12455 {
12456         struct alc_spec *spec = codec->spec;
12457         unsigned int mute;
12458
12459         if (force || !spec->sense_updated) {
12460                 spec->jack_present = snd_hda_jack_detect(codec, 0x14);
12461                 spec->sense_updated = 1;
12462         }
12463         if (spec->jack_present)
12464                 mute = HDA_AMP_MUTE; /* mute internal speaker */
12465         else /* unmute internal speaker if necessary */
12466                 mute = snd_hda_codec_amp_read(codec, 0x14, 0, HDA_OUTPUT, 0);
12467         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
12468                                  HDA_AMP_MUTE, mute);
12469 }
12470
12471
12472 /* bind hp and internal speaker mute (with plug check) */
12473 static int alc268_acer_master_sw_put(struct snd_kcontrol *kcontrol,
12474                                      struct snd_ctl_elem_value *ucontrol)
12475 {
12476         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
12477         long *valp = ucontrol->value.integer.value;
12478         int change;
12479
12480         change = amp_stereo_mute_update(codec, 0x14, HDA_OUTPUT, 0, valp);
12481         if (change)
12482                 alc268_acer_automute(codec, 0);
12483         return change;
12484 }
12485
12486 static struct snd_kcontrol_new alc268_acer_aspire_one_mixer[] = {
12487         /* output mixer control */
12488         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12489         {
12490                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12491                 .name = "Master Playback Switch",
12492                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12493                 .info = snd_hda_mixer_amp_switch_info,
12494                 .get = snd_hda_mixer_amp_switch_get,
12495                 .put = alc268_acer_master_sw_put,
12496                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12497         },
12498         HDA_CODEC_VOLUME("Mic Boost Capture Volume", 0x18, 0, HDA_INPUT),
12499         { }
12500 };
12501
12502 static struct snd_kcontrol_new alc268_acer_mixer[] = {
12503         /* output mixer control */
12504         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12505         {
12506                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12507                 .name = "Master Playback Switch",
12508                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12509                 .info = snd_hda_mixer_amp_switch_info,
12510                 .get = snd_hda_mixer_amp_switch_get,
12511                 .put = alc268_acer_master_sw_put,
12512                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12513         },
12514         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12515         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12516         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12517         { }
12518 };
12519
12520 static struct snd_kcontrol_new alc268_acer_dmic_mixer[] = {
12521         /* output mixer control */
12522         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
12523         {
12524                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
12525                 .name = "Master Playback Switch",
12526                 .subdevice = HDA_SUBDEV_AMP_FLAG,
12527                 .info = snd_hda_mixer_amp_switch_info,
12528                 .get = snd_hda_mixer_amp_switch_get,
12529                 .put = alc268_acer_master_sw_put,
12530                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
12531         },
12532         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12533         HDA_CODEC_VOLUME("Line In Boost", 0x1a, 0, HDA_INPUT),
12534         { }
12535 };
12536
12537 static struct hda_verb alc268_acer_aspire_one_verbs[] = {
12538         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12539         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12540         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12541         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
12542         {0x23, AC_VERB_SET_CONNECT_SEL, 0x06},
12543         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, 0xa017},
12544         { }
12545 };
12546
12547 static struct hda_verb alc268_acer_verbs[] = {
12548         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN}, /* internal dmic? */
12549         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
12550         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12551         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
12552         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12553         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
12554         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12555         { }
12556 };
12557
12558 /* unsolicited event for HP jack sensing */
12559 #define alc268_toshiba_unsol_event      alc262_hippo_unsol_event
12560 #define alc268_toshiba_setup            alc262_hippo_setup
12561 #define alc268_toshiba_automute         alc262_hippo_automute
12562
12563 static void alc268_acer_unsol_event(struct hda_codec *codec,
12564                                        unsigned int res)
12565 {
12566         if ((res >> 26) != ALC880_HP_EVENT)
12567                 return;
12568         alc268_acer_automute(codec, 1);
12569 }
12570
12571 static void alc268_acer_init_hook(struct hda_codec *codec)
12572 {
12573         alc268_acer_automute(codec, 1);
12574 }
12575
12576 /* toggle speaker-output according to the hp-jack state */
12577 static void alc268_aspire_one_speaker_automute(struct hda_codec *codec)
12578 {
12579         unsigned int present;
12580         unsigned char bits;
12581
12582         present = snd_hda_jack_detect(codec, 0x15);
12583         bits = present ? HDA_AMP_MUTE : 0;
12584         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 0,
12585                                  HDA_AMP_MUTE, bits);
12586         snd_hda_codec_amp_stereo(codec, 0x0f, HDA_INPUT, 1,
12587                                  HDA_AMP_MUTE, bits);
12588 }
12589
12590 static void alc268_acer_lc_unsol_event(struct hda_codec *codec,
12591                                     unsigned int res)
12592 {
12593         switch (res >> 26) {
12594         case ALC880_HP_EVENT:
12595                 alc268_aspire_one_speaker_automute(codec);
12596                 break;
12597         case ALC880_MIC_EVENT:
12598                 alc_mic_automute(codec);
12599                 break;
12600         }
12601 }
12602
12603 static void alc268_acer_lc_setup(struct hda_codec *codec)
12604 {
12605         struct alc_spec *spec = codec->spec;
12606         spec->ext_mic.pin = 0x18;
12607         spec->ext_mic.mux_idx = 0;
12608         spec->int_mic.pin = 0x12;
12609         spec->int_mic.mux_idx = 6;
12610         spec->auto_mic = 1;
12611 }
12612
12613 static void alc268_acer_lc_init_hook(struct hda_codec *codec)
12614 {
12615         alc268_aspire_one_speaker_automute(codec);
12616         alc_mic_automute(codec);
12617 }
12618
12619 static struct snd_kcontrol_new alc268_dell_mixer[] = {
12620         /* output mixer control */
12621         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12622         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12623         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12624         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12625         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
12626         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
12627         { }
12628 };
12629
12630 static struct hda_verb alc268_dell_verbs[] = {
12631         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12632         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
12633         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12634         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12635         { }
12636 };
12637
12638 /* mute/unmute internal speaker according to the hp jack and mute state */
12639 static void alc268_dell_setup(struct hda_codec *codec)
12640 {
12641         struct alc_spec *spec = codec->spec;
12642
12643         spec->autocfg.hp_pins[0] = 0x15;
12644         spec->autocfg.speaker_pins[0] = 0x14;
12645         spec->ext_mic.pin = 0x18;
12646         spec->ext_mic.mux_idx = 0;
12647         spec->int_mic.pin = 0x19;
12648         spec->int_mic.mux_idx = 1;
12649         spec->auto_mic = 1;
12650 }
12651
12652 static struct snd_kcontrol_new alc267_quanta_il1_mixer[] = {
12653         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x2, 0x0, HDA_OUTPUT),
12654         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
12655         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x3, 0x0, HDA_OUTPUT),
12656         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
12657         HDA_CODEC_VOLUME("Mic Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12658         HDA_BIND_MUTE("Mic Capture Switch", 0x23, 2, HDA_OUTPUT),
12659         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
12660         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
12661         { }
12662 };
12663
12664 static struct hda_verb alc267_quanta_il1_verbs[] = {
12665         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
12666         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_MIC_EVENT | AC_USRSP_EN},
12667         { }
12668 };
12669
12670 static void alc267_quanta_il1_setup(struct hda_codec *codec)
12671 {
12672         struct alc_spec *spec = codec->spec;
12673         spec->autocfg.hp_pins[0] = 0x15;
12674         spec->autocfg.speaker_pins[0] = 0x14;
12675         spec->ext_mic.pin = 0x18;
12676         spec->ext_mic.mux_idx = 0;
12677         spec->int_mic.pin = 0x19;
12678         spec->int_mic.mux_idx = 1;
12679         spec->auto_mic = 1;
12680 }
12681
12682 /*
12683  * generic initialization of ADC, input mixers and output mixers
12684  */
12685 static struct hda_verb alc268_base_init_verbs[] = {
12686         /* Unmute DAC0-1 and set vol = 0 */
12687         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12688         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12689
12690         /*
12691          * Set up output mixers (0x0c - 0x0e)
12692          */
12693         /* set vol=0 to output mixers */
12694         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12695         {0x0e, AC_VERB_SET_CONNECT_SEL, 0x00},
12696
12697         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12698         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12699
12700         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12701         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0},
12702         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40},
12703         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12704         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12705         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12706         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12707         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12708
12709         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12710         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12711         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12712         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12713         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12714
12715         /* set PCBEEP vol = 0, mute connections */
12716         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12717         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12718         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12719
12720         /* Unmute Selector 23h,24h and set the default input to mic-in */
12721
12722         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
12723         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12724         {0x24, AC_VERB_SET_CONNECT_SEL, 0x00},
12725         {0x24, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
12726
12727         { }
12728 };
12729
12730 /*
12731  * generic initialization of ADC, input mixers and output mixers
12732  */
12733 static struct hda_verb alc268_volume_init_verbs[] = {
12734         /* set output DAC */
12735         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12736         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
12737
12738         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12739         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24},
12740         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12741         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12742         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20},
12743
12744         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12745         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12746         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12747
12748         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
12750
12751         /* set PCBEEP vol = 0, mute connections */
12752         {0x1d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
12753         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12754         {0x10, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
12755
12756         { }
12757 };
12758
12759 static struct snd_kcontrol_new alc268_capture_nosrc_mixer[] = {
12760         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12761         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12762         { } /* end */
12763 };
12764
12765 static struct snd_kcontrol_new alc268_capture_alt_mixer[] = {
12766         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12767         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12768         _DEFINE_CAPSRC(1),
12769         { } /* end */
12770 };
12771
12772 static struct snd_kcontrol_new alc268_capture_mixer[] = {
12773         HDA_CODEC_VOLUME("Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12774         HDA_CODEC_MUTE("Capture Switch", 0x23, 0x0, HDA_OUTPUT),
12775         HDA_CODEC_VOLUME_IDX("Capture Volume", 1, 0x24, 0x0, HDA_OUTPUT),
12776         HDA_CODEC_MUTE_IDX("Capture Switch", 1, 0x24, 0x0, HDA_OUTPUT),
12777         _DEFINE_CAPSRC(2),
12778         { } /* end */
12779 };
12780
12781 static struct hda_input_mux alc268_capture_source = {
12782         .num_items = 4,
12783         .items = {
12784                 { "Mic", 0x0 },
12785                 { "Front Mic", 0x1 },
12786                 { "Line", 0x2 },
12787                 { "CD", 0x3 },
12788         },
12789 };
12790
12791 static struct hda_input_mux alc268_acer_capture_source = {
12792         .num_items = 3,
12793         .items = {
12794                 { "Mic", 0x0 },
12795                 { "Internal Mic", 0x1 },
12796                 { "Line", 0x2 },
12797         },
12798 };
12799
12800 static struct hda_input_mux alc268_acer_dmic_capture_source = {
12801         .num_items = 3,
12802         .items = {
12803                 { "Mic", 0x0 },
12804                 { "Internal Mic", 0x6 },
12805                 { "Line", 0x2 },
12806         },
12807 };
12808
12809 #ifdef CONFIG_SND_DEBUG
12810 static struct snd_kcontrol_new alc268_test_mixer[] = {
12811         /* Volume widgets */
12812         HDA_CODEC_VOLUME("LOUT1 Playback Volume", 0x02, 0x0, HDA_OUTPUT),
12813         HDA_CODEC_VOLUME("LOUT2 Playback Volume", 0x03, 0x0, HDA_OUTPUT),
12814         HDA_BIND_MUTE_MONO("Mono sum Playback Switch", 0x0e, 1, 2, HDA_INPUT),
12815         HDA_BIND_MUTE("LINE-OUT sum Playback Switch", 0x0f, 2, HDA_INPUT),
12816         HDA_BIND_MUTE("HP-OUT sum Playback Switch", 0x10, 2, HDA_INPUT),
12817         HDA_BIND_MUTE("LINE-OUT Playback Switch", 0x14, 2, HDA_OUTPUT),
12818         HDA_BIND_MUTE("HP-OUT Playback Switch", 0x15, 2, HDA_OUTPUT),
12819         HDA_BIND_MUTE("Mono Playback Switch", 0x16, 2, HDA_OUTPUT),
12820         HDA_CODEC_VOLUME("MIC1 Capture Volume", 0x18, 0x0, HDA_INPUT),
12821         HDA_BIND_MUTE("MIC1 Capture Switch", 0x18, 2, HDA_OUTPUT),
12822         HDA_CODEC_VOLUME("MIC2 Capture Volume", 0x19, 0x0, HDA_INPUT),
12823         HDA_CODEC_VOLUME("LINE1 Capture Volume", 0x1a, 0x0, HDA_INPUT),
12824         HDA_BIND_MUTE("LINE1 Capture Switch", 0x1a, 2, HDA_OUTPUT),
12825         /* The below appears problematic on some hardwares */
12826         /*HDA_CODEC_VOLUME("PCBEEP Playback Volume", 0x1d, 0x0, HDA_INPUT),*/
12827         HDA_CODEC_VOLUME("PCM-IN1 Capture Volume", 0x23, 0x0, HDA_OUTPUT),
12828         HDA_BIND_MUTE("PCM-IN1 Capture Switch", 0x23, 2, HDA_OUTPUT),
12829         HDA_CODEC_VOLUME("PCM-IN2 Capture Volume", 0x24, 0x0, HDA_OUTPUT),
12830         HDA_BIND_MUTE("PCM-IN2 Capture Switch", 0x24, 2, HDA_OUTPUT),
12831
12832         /* Modes for retasking pin widgets */
12833         ALC_PIN_MODE("LINE-OUT pin mode", 0x14, ALC_PIN_DIR_INOUT),
12834         ALC_PIN_MODE("HP-OUT pin mode", 0x15, ALC_PIN_DIR_INOUT),
12835         ALC_PIN_MODE("MIC1 pin mode", 0x18, ALC_PIN_DIR_INOUT),
12836         ALC_PIN_MODE("LINE1 pin mode", 0x1a, ALC_PIN_DIR_INOUT),
12837
12838         /* Controls for GPIO pins, assuming they are configured as outputs */
12839         ALC_GPIO_DATA_SWITCH("GPIO pin 0", 0x01, 0x01),
12840         ALC_GPIO_DATA_SWITCH("GPIO pin 1", 0x01, 0x02),
12841         ALC_GPIO_DATA_SWITCH("GPIO pin 2", 0x01, 0x04),
12842         ALC_GPIO_DATA_SWITCH("GPIO pin 3", 0x01, 0x08),
12843
12844         /* Switches to allow the digital SPDIF output pin to be enabled.
12845          * The ALC268 does not have an SPDIF input.
12846          */
12847         ALC_SPDIF_CTRL_SWITCH("SPDIF Playback Switch", 0x06, 0x01),
12848
12849         /* A switch allowing EAPD to be enabled.  Some laptops seem to use
12850          * this output to turn on an external amplifier.
12851          */
12852         ALC_EAPD_CTRL_SWITCH("LINE-OUT EAPD Enable Switch", 0x0f, 0x02),
12853         ALC_EAPD_CTRL_SWITCH("HP-OUT EAPD Enable Switch", 0x10, 0x02),
12854
12855         { } /* end */
12856 };
12857 #endif
12858
12859 /* create input playback/capture controls for the given pin */
12860 static int alc268_new_analog_output(struct alc_spec *spec, hda_nid_t nid,
12861                                     const char *ctlname, int idx)
12862 {
12863         hda_nid_t dac;
12864         int err;
12865
12866         switch (nid) {
12867         case 0x14:
12868         case 0x16:
12869                 dac = 0x02;
12870                 break;
12871         case 0x15:
12872         case 0x21: /* ALC269vb has this pin, too */
12873                 dac = 0x03;
12874                 break;
12875         default:
12876                 return 0;
12877         }
12878         if (spec->multiout.dac_nids[0] != dac &&
12879             spec->multiout.dac_nids[1] != dac) {
12880                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, ctlname,
12881                                   HDA_COMPOSE_AMP_VAL(dac, 3, idx,
12882                                                       HDA_OUTPUT));
12883                 if (err < 0)
12884                         return err;
12885                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
12886         }
12887
12888         if (nid != 0x16)
12889                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12890                           HDA_COMPOSE_AMP_VAL(nid, 3, idx, HDA_OUTPUT));
12891         else /* mono */
12892                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, ctlname,
12893                           HDA_COMPOSE_AMP_VAL(nid, 2, idx, HDA_OUTPUT));
12894         if (err < 0)
12895                 return err;
12896         return 0;
12897 }
12898
12899 /* add playback controls from the parsed DAC table */
12900 static int alc268_auto_create_multi_out_ctls(struct alc_spec *spec,
12901                                              const struct auto_pin_cfg *cfg)
12902 {
12903         hda_nid_t nid;
12904         int err;
12905
12906         spec->multiout.dac_nids = spec->private_dac_nids;
12907
12908         nid = cfg->line_out_pins[0];
12909         if (nid) {
12910                 const char *name;
12911                 if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
12912                         name = "Speaker";
12913                 else
12914                         name = "Front";
12915                 err = alc268_new_analog_output(spec, nid, name, 0);
12916                 if (err < 0)
12917                         return err;
12918         }
12919
12920         nid = cfg->speaker_pins[0];
12921         if (nid == 0x1d) {
12922                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, "Speaker",
12923                                   HDA_COMPOSE_AMP_VAL(nid, 3, 0, HDA_INPUT));
12924                 if (err < 0)
12925                         return err;
12926         } else {
12927                 err = alc268_new_analog_output(spec, nid, "Speaker", 0);
12928                 if (err < 0)
12929                         return err;
12930         }
12931         nid = cfg->hp_pins[0];
12932         if (nid) {
12933                 err = alc268_new_analog_output(spec, nid, "Headphone", 0);
12934                 if (err < 0)
12935                         return err;
12936         }
12937
12938         nid = cfg->line_out_pins[1] | cfg->line_out_pins[2];
12939         if (nid == 0x16) {
12940                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, "Mono",
12941                                   HDA_COMPOSE_AMP_VAL(nid, 2, 0, HDA_OUTPUT));
12942                 if (err < 0)
12943                         return err;
12944         }
12945         return 0;
12946 }
12947
12948 /* create playback/capture controls for input pins */
12949 static int alc268_auto_create_input_ctls(struct hda_codec *codec,
12950                                                 const struct auto_pin_cfg *cfg)
12951 {
12952         return alc_auto_create_input_ctls(codec, cfg, 0, 0x23, 0x24);
12953 }
12954
12955 static void alc268_auto_set_output_and_unmute(struct hda_codec *codec,
12956                                               hda_nid_t nid, int pin_type)
12957 {
12958         int idx;
12959
12960         alc_set_pin_output(codec, nid, pin_type);
12961         if (nid == 0x14 || nid == 0x16)
12962                 idx = 0;
12963         else
12964                 idx = 1;
12965         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, idx);
12966 }
12967
12968 static void alc268_auto_init_multi_out(struct hda_codec *codec)
12969 {
12970         struct alc_spec *spec = codec->spec;
12971         hda_nid_t nid = spec->autocfg.line_out_pins[0];
12972         if (nid) {
12973                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
12974                 alc268_auto_set_output_and_unmute(codec, nid, pin_type);
12975         }
12976 }
12977
12978 static void alc268_auto_init_hp_out(struct hda_codec *codec)
12979 {
12980         struct alc_spec *spec = codec->spec;
12981         hda_nid_t pin;
12982
12983         pin = spec->autocfg.hp_pins[0];
12984         if (pin)
12985                 alc268_auto_set_output_and_unmute(codec, pin, PIN_HP);
12986         pin = spec->autocfg.speaker_pins[0];
12987         if (pin)
12988                 alc268_auto_set_output_and_unmute(codec, pin, PIN_OUT);
12989 }
12990
12991 static void alc268_auto_init_mono_speaker_out(struct hda_codec *codec)
12992 {
12993         struct alc_spec *spec = codec->spec;
12994         hda_nid_t speaker_nid = spec->autocfg.speaker_pins[0];
12995         hda_nid_t hp_nid = spec->autocfg.hp_pins[0];
12996         hda_nid_t line_nid = spec->autocfg.line_out_pins[0];
12997         unsigned int    dac_vol1, dac_vol2;
12998
12999         if (line_nid == 0x1d || speaker_nid == 0x1d) {
13000                 snd_hda_codec_write(codec, speaker_nid, 0,
13001                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
13002                 /* mute mixer inputs from 0x1d */
13003                 snd_hda_codec_write(codec, 0x0f, 0,
13004                                     AC_VERB_SET_AMP_GAIN_MUTE,
13005                                     AMP_IN_UNMUTE(1));
13006                 snd_hda_codec_write(codec, 0x10, 0,
13007                                     AC_VERB_SET_AMP_GAIN_MUTE,
13008                                     AMP_IN_UNMUTE(1));
13009         } else {
13010                 /* unmute mixer inputs from 0x1d */
13011                 snd_hda_codec_write(codec, 0x0f, 0,
13012                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13013                 snd_hda_codec_write(codec, 0x10, 0,
13014                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1));
13015         }
13016
13017         dac_vol1 = dac_vol2 = 0xb000 | 0x40;    /* set max volume  */
13018         if (line_nid == 0x14)
13019                 dac_vol2 = AMP_OUT_ZERO;
13020         else if (line_nid == 0x15)
13021                 dac_vol1 = AMP_OUT_ZERO;
13022         if (hp_nid == 0x14)
13023                 dac_vol2 = AMP_OUT_ZERO;
13024         else if (hp_nid == 0x15)
13025                 dac_vol1 = AMP_OUT_ZERO;
13026         if (line_nid != 0x16 || hp_nid != 0x16 ||
13027             spec->autocfg.line_out_pins[1] != 0x16 ||
13028             spec->autocfg.line_out_pins[2] != 0x16)
13029                 dac_vol1 = dac_vol2 = AMP_OUT_ZERO;
13030
13031         snd_hda_codec_write(codec, 0x02, 0,
13032                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol1);
13033         snd_hda_codec_write(codec, 0x03, 0,
13034                             AC_VERB_SET_AMP_GAIN_MUTE, dac_vol2);
13035 }
13036
13037 /* pcm configuration: identical with ALC880 */
13038 #define alc268_pcm_analog_playback      alc880_pcm_analog_playback
13039 #define alc268_pcm_analog_capture       alc880_pcm_analog_capture
13040 #define alc268_pcm_analog_alt_capture   alc880_pcm_analog_alt_capture
13041 #define alc268_pcm_digital_playback     alc880_pcm_digital_playback
13042
13043 /*
13044  * BIOS auto configuration
13045  */
13046 static int alc268_parse_auto_config(struct hda_codec *codec)
13047 {
13048         struct alc_spec *spec = codec->spec;
13049         int err;
13050         static hda_nid_t alc268_ignore[] = { 0 };
13051
13052         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13053                                            alc268_ignore);
13054         if (err < 0)
13055                 return err;
13056         if (!spec->autocfg.line_outs) {
13057                 if (spec->autocfg.dig_outs || spec->autocfg.dig_in_pin) {
13058                         spec->multiout.max_channels = 2;
13059                         spec->no_analog = 1;
13060                         goto dig_only;
13061                 }
13062                 return 0; /* can't find valid BIOS pin config */
13063         }
13064         err = alc268_auto_create_multi_out_ctls(spec, &spec->autocfg);
13065         if (err < 0)
13066                 return err;
13067         err = alc268_auto_create_input_ctls(codec, &spec->autocfg);
13068         if (err < 0)
13069                 return err;
13070
13071         spec->multiout.max_channels = 2;
13072
13073  dig_only:
13074         /* digital only support output */
13075         if (spec->autocfg.dig_outs) {
13076                 spec->multiout.dig_out_nid = ALC268_DIGOUT_NID;
13077                 spec->dig_out_type = spec->autocfg.dig_out_type[0];
13078         }
13079         if (spec->kctls.list)
13080                 add_mixer(spec, spec->kctls.list);
13081
13082         if (!spec->no_analog && spec->autocfg.speaker_pins[0] != 0x1d)
13083                 add_mixer(spec, alc268_beep_mixer);
13084
13085         add_verb(spec, alc268_volume_init_verbs);
13086         spec->num_mux_defs = 2;
13087         spec->input_mux = &spec->private_imux[0];
13088
13089         err = alc_auto_add_mic_boost(codec);
13090         if (err < 0)
13091                 return err;
13092
13093         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
13094
13095         return 1;
13096 }
13097
13098 #define alc268_auto_init_analog_input   alc882_auto_init_analog_input
13099
13100 /* init callback for auto-configuration model -- overriding the default init */
13101 static void alc268_auto_init(struct hda_codec *codec)
13102 {
13103         struct alc_spec *spec = codec->spec;
13104         alc268_auto_init_multi_out(codec);
13105         alc268_auto_init_hp_out(codec);
13106         alc268_auto_init_mono_speaker_out(codec);
13107         alc268_auto_init_analog_input(codec);
13108         if (spec->unsol_event)
13109                 alc_inithook(codec);
13110 }
13111
13112 /*
13113  * configuration and preset
13114  */
13115 static const char *alc268_models[ALC268_MODEL_LAST] = {
13116         [ALC267_QUANTA_IL1]     = "quanta-il1",
13117         [ALC268_3ST]            = "3stack",
13118         [ALC268_TOSHIBA]        = "toshiba",
13119         [ALC268_ACER]           = "acer",
13120         [ALC268_ACER_DMIC]      = "acer-dmic",
13121         [ALC268_ACER_ASPIRE_ONE]        = "acer-aspire",
13122         [ALC268_DELL]           = "dell",
13123         [ALC268_ZEPTO]          = "zepto",
13124 #ifdef CONFIG_SND_DEBUG
13125         [ALC268_TEST]           = "test",
13126 #endif
13127         [ALC268_AUTO]           = "auto",
13128 };
13129
13130 static struct snd_pci_quirk alc268_cfg_tbl[] = {
13131         SND_PCI_QUIRK(0x1025, 0x011e, "Acer Aspire 5720z", ALC268_ACER),
13132         SND_PCI_QUIRK(0x1025, 0x0126, "Acer", ALC268_ACER),
13133         SND_PCI_QUIRK(0x1025, 0x012e, "Acer Aspire 5310", ALC268_ACER),
13134         SND_PCI_QUIRK(0x1025, 0x0130, "Acer Extensa 5210", ALC268_ACER),
13135         SND_PCI_QUIRK(0x1025, 0x0136, "Acer Aspire 5315", ALC268_ACER),
13136         SND_PCI_QUIRK(0x1025, 0x015b, "Acer Aspire One",
13137                                                 ALC268_ACER_ASPIRE_ONE),
13138         SND_PCI_QUIRK(0x1028, 0x0253, "Dell OEM", ALC268_DELL),
13139         SND_PCI_QUIRK_MASK(0x1028, 0xfff0, 0x02b0,
13140                         "Dell Inspiron Mini9/Vostro A90", ALC268_DELL),
13141         /* almost compatible with toshiba but with optional digital outs;
13142          * auto-probing seems working fine
13143          */
13144         SND_PCI_QUIRK_MASK(0x103c, 0xff00, 0x3000, "HP TX25xx series",
13145                            ALC268_AUTO),
13146         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC268_3ST),
13147         SND_PCI_QUIRK(0x1170, 0x0040, "ZEPTO", ALC268_ZEPTO),
13148         SND_PCI_QUIRK(0x14c0, 0x0025, "COMPAL IFL90/JFL-92", ALC268_TOSHIBA),
13149         SND_PCI_QUIRK(0x152d, 0x0763, "Diverse (CPR2000)", ALC268_ACER),
13150         SND_PCI_QUIRK(0x152d, 0x0771, "Quanta IL1", ALC267_QUANTA_IL1),
13151         SND_PCI_QUIRK(0x1854, 0x1775, "LG R510", ALC268_DELL),
13152         {}
13153 };
13154
13155 /* Toshiba laptops have no unique PCI SSID but only codec SSID */
13156 static struct snd_pci_quirk alc268_ssid_cfg_tbl[] = {
13157         SND_PCI_QUIRK(0x1179, 0xff0a, "TOSHIBA X-200", ALC268_AUTO),
13158         SND_PCI_QUIRK(0x1179, 0xff0e, "TOSHIBA X-200 HDMI", ALC268_AUTO),
13159         SND_PCI_QUIRK_MASK(0x1179, 0xff00, 0xff00, "TOSHIBA A/Lx05",
13160                            ALC268_TOSHIBA),
13161         {}
13162 };
13163
13164 static struct alc_config_preset alc268_presets[] = {
13165         [ALC267_QUANTA_IL1] = {
13166                 .mixers = { alc267_quanta_il1_mixer, alc268_beep_mixer,
13167                             alc268_capture_nosrc_mixer },
13168                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13169                                 alc267_quanta_il1_verbs },
13170                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13171                 .dac_nids = alc268_dac_nids,
13172                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13173                 .adc_nids = alc268_adc_nids_alt,
13174                 .hp_nid = 0x03,
13175                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13176                 .channel_mode = alc268_modes,
13177                 .unsol_event = alc_sku_unsol_event,
13178                 .setup = alc267_quanta_il1_setup,
13179                 .init_hook = alc_inithook,
13180         },
13181         [ALC268_3ST] = {
13182                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13183                             alc268_beep_mixer },
13184                 .init_verbs = { alc268_base_init_verbs },
13185                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13186                 .dac_nids = alc268_dac_nids,
13187                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13188                 .adc_nids = alc268_adc_nids_alt,
13189                 .capsrc_nids = alc268_capsrc_nids,
13190                 .hp_nid = 0x03,
13191                 .dig_out_nid = ALC268_DIGOUT_NID,
13192                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13193                 .channel_mode = alc268_modes,
13194                 .input_mux = &alc268_capture_source,
13195         },
13196         [ALC268_TOSHIBA] = {
13197                 .mixers = { alc268_toshiba_mixer, alc268_capture_alt_mixer,
13198                             alc268_beep_mixer },
13199                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13200                                 alc268_toshiba_verbs },
13201                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13202                 .dac_nids = alc268_dac_nids,
13203                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13204                 .adc_nids = alc268_adc_nids_alt,
13205                 .capsrc_nids = alc268_capsrc_nids,
13206                 .hp_nid = 0x03,
13207                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13208                 .channel_mode = alc268_modes,
13209                 .input_mux = &alc268_capture_source,
13210                 .unsol_event = alc268_toshiba_unsol_event,
13211                 .setup = alc268_toshiba_setup,
13212                 .init_hook = alc268_toshiba_automute,
13213         },
13214         [ALC268_ACER] = {
13215                 .mixers = { alc268_acer_mixer, alc268_capture_alt_mixer,
13216                             alc268_beep_mixer },
13217                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13218                                 alc268_acer_verbs },
13219                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13220                 .dac_nids = alc268_dac_nids,
13221                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13222                 .adc_nids = alc268_adc_nids_alt,
13223                 .capsrc_nids = alc268_capsrc_nids,
13224                 .hp_nid = 0x02,
13225                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13226                 .channel_mode = alc268_modes,
13227                 .input_mux = &alc268_acer_capture_source,
13228                 .unsol_event = alc268_acer_unsol_event,
13229                 .init_hook = alc268_acer_init_hook,
13230         },
13231         [ALC268_ACER_DMIC] = {
13232                 .mixers = { alc268_acer_dmic_mixer, alc268_capture_alt_mixer,
13233                             alc268_beep_mixer },
13234                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13235                                 alc268_acer_verbs },
13236                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13237                 .dac_nids = alc268_dac_nids,
13238                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13239                 .adc_nids = alc268_adc_nids_alt,
13240                 .capsrc_nids = alc268_capsrc_nids,
13241                 .hp_nid = 0x02,
13242                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13243                 .channel_mode = alc268_modes,
13244                 .input_mux = &alc268_acer_dmic_capture_source,
13245                 .unsol_event = alc268_acer_unsol_event,
13246                 .init_hook = alc268_acer_init_hook,
13247         },
13248         [ALC268_ACER_ASPIRE_ONE] = {
13249                 .mixers = { alc268_acer_aspire_one_mixer,
13250                             alc268_beep_mixer,
13251                             alc268_capture_nosrc_mixer },
13252                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13253                                 alc268_acer_aspire_one_verbs },
13254                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13255                 .dac_nids = alc268_dac_nids,
13256                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13257                 .adc_nids = alc268_adc_nids_alt,
13258                 .capsrc_nids = alc268_capsrc_nids,
13259                 .hp_nid = 0x03,
13260                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13261                 .channel_mode = alc268_modes,
13262                 .unsol_event = alc268_acer_lc_unsol_event,
13263                 .setup = alc268_acer_lc_setup,
13264                 .init_hook = alc268_acer_lc_init_hook,
13265         },
13266         [ALC268_DELL] = {
13267                 .mixers = { alc268_dell_mixer, alc268_beep_mixer,
13268                             alc268_capture_nosrc_mixer },
13269                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13270                                 alc268_dell_verbs },
13271                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13272                 .dac_nids = alc268_dac_nids,
13273                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13274                 .adc_nids = alc268_adc_nids_alt,
13275                 .capsrc_nids = alc268_capsrc_nids,
13276                 .hp_nid = 0x02,
13277                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13278                 .channel_mode = alc268_modes,
13279                 .unsol_event = alc_sku_unsol_event,
13280                 .setup = alc268_dell_setup,
13281                 .init_hook = alc_inithook,
13282         },
13283         [ALC268_ZEPTO] = {
13284                 .mixers = { alc268_base_mixer, alc268_capture_alt_mixer,
13285                             alc268_beep_mixer },
13286                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13287                                 alc268_toshiba_verbs },
13288                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13289                 .dac_nids = alc268_dac_nids,
13290                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13291                 .adc_nids = alc268_adc_nids_alt,
13292                 .capsrc_nids = alc268_capsrc_nids,
13293                 .hp_nid = 0x03,
13294                 .dig_out_nid = ALC268_DIGOUT_NID,
13295                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13296                 .channel_mode = alc268_modes,
13297                 .input_mux = &alc268_capture_source,
13298                 .setup = alc268_toshiba_setup,
13299                 .init_hook = alc268_toshiba_automute,
13300         },
13301 #ifdef CONFIG_SND_DEBUG
13302         [ALC268_TEST] = {
13303                 .mixers = { alc268_test_mixer, alc268_capture_mixer },
13304                 .init_verbs = { alc268_base_init_verbs, alc268_eapd_verbs,
13305                                 alc268_volume_init_verbs },
13306                 .num_dacs = ARRAY_SIZE(alc268_dac_nids),
13307                 .dac_nids = alc268_dac_nids,
13308                 .num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt),
13309                 .adc_nids = alc268_adc_nids_alt,
13310                 .capsrc_nids = alc268_capsrc_nids,
13311                 .hp_nid = 0x03,
13312                 .dig_out_nid = ALC268_DIGOUT_NID,
13313                 .num_channel_mode = ARRAY_SIZE(alc268_modes),
13314                 .channel_mode = alc268_modes,
13315                 .input_mux = &alc268_capture_source,
13316         },
13317 #endif
13318 };
13319
13320 static int patch_alc268(struct hda_codec *codec)
13321 {
13322         struct alc_spec *spec;
13323         int board_config;
13324         int i, has_beep, err;
13325
13326         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
13327         if (spec == NULL)
13328                 return -ENOMEM;
13329
13330         codec->spec = spec;
13331
13332         board_config = snd_hda_check_board_config(codec, ALC268_MODEL_LAST,
13333                                                   alc268_models,
13334                                                   alc268_cfg_tbl);
13335
13336         if (board_config < 0 || board_config >= ALC268_MODEL_LAST)
13337                 board_config = snd_hda_check_board_codec_sid_config(codec,
13338                         ALC268_MODEL_LAST, alc268_models, alc268_ssid_cfg_tbl);
13339
13340         if (board_config < 0 || board_config >= ALC268_MODEL_LAST) {
13341                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
13342                        codec->chip_name);
13343                 board_config = ALC268_AUTO;
13344         }
13345
13346         if (board_config == ALC268_AUTO) {
13347                 /* automatic parse from the BIOS config */
13348                 err = alc268_parse_auto_config(codec);
13349                 if (err < 0) {
13350                         alc_free(codec);
13351                         return err;
13352                 } else if (!err) {
13353                         printk(KERN_INFO
13354                                "hda_codec: Cannot set up configuration "
13355                                "from BIOS.  Using base mode...\n");
13356                         board_config = ALC268_3ST;
13357                 }
13358         }
13359
13360         if (board_config != ALC268_AUTO)
13361                 setup_preset(codec, &alc268_presets[board_config]);
13362
13363         spec->stream_analog_playback = &alc268_pcm_analog_playback;
13364         spec->stream_analog_capture = &alc268_pcm_analog_capture;
13365         spec->stream_analog_alt_capture = &alc268_pcm_analog_alt_capture;
13366
13367         spec->stream_digital_playback = &alc268_pcm_digital_playback;
13368
13369         has_beep = 0;
13370         for (i = 0; i < spec->num_mixers; i++) {
13371                 if (spec->mixers[i] == alc268_beep_mixer) {
13372                         has_beep = 1;
13373                         break;
13374                 }
13375         }
13376
13377         if (has_beep) {
13378                 err = snd_hda_attach_beep_device(codec, 0x1);
13379                 if (err < 0) {
13380                         alc_free(codec);
13381                         return err;
13382                 }
13383                 if (!query_amp_caps(codec, 0x1d, HDA_INPUT))
13384                         /* override the amp caps for beep generator */
13385                         snd_hda_override_amp_caps(codec, 0x1d, HDA_INPUT,
13386                                           (0x0c << AC_AMPCAP_OFFSET_SHIFT) |
13387                                           (0x0c << AC_AMPCAP_NUM_STEPS_SHIFT) |
13388                                           (0x07 << AC_AMPCAP_STEP_SIZE_SHIFT) |
13389                                           (0 << AC_AMPCAP_MUTE_SHIFT));
13390         }
13391
13392         if (!spec->no_analog && !spec->adc_nids && spec->input_mux) {
13393                 /* check whether NID 0x07 is valid */
13394                 unsigned int wcap = get_wcaps(codec, 0x07);
13395                 int i;
13396
13397                 spec->capsrc_nids = alc268_capsrc_nids;
13398                 /* get type */
13399                 wcap = get_wcaps_type(wcap);
13400                 if (spec->auto_mic ||
13401                     wcap != AC_WID_AUD_IN || spec->input_mux->num_items == 1) {
13402                         spec->adc_nids = alc268_adc_nids_alt;
13403                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids_alt);
13404                         if (spec->auto_mic)
13405                                 fixup_automic_adc(codec);
13406                         if (spec->auto_mic || spec->input_mux->num_items == 1)
13407                                 add_mixer(spec, alc268_capture_nosrc_mixer);
13408                         else
13409                                 add_mixer(spec, alc268_capture_alt_mixer);
13410                 } else {
13411                         spec->adc_nids = alc268_adc_nids;
13412                         spec->num_adc_nids = ARRAY_SIZE(alc268_adc_nids);
13413                         add_mixer(spec, alc268_capture_mixer);
13414                 }
13415                 /* set default input source */
13416                 for (i = 0; i < spec->num_adc_nids; i++)
13417                         snd_hda_codec_write_cache(codec, alc268_capsrc_nids[i],
13418                                 0, AC_VERB_SET_CONNECT_SEL,
13419                                 i < spec->num_mux_defs ?
13420                                 spec->input_mux[i].items[0].index :
13421                                 spec->input_mux->items[0].index);
13422         }
13423
13424         spec->vmaster_nid = 0x02;
13425
13426         codec->patch_ops = alc_patch_ops;
13427         if (board_config == ALC268_AUTO)
13428                 spec->init_hook = alc268_auto_init;
13429
13430         return 0;
13431 }
13432
13433 /*
13434  *  ALC269 channel source setting (2 channel)
13435  */
13436 #define ALC269_DIGOUT_NID       ALC880_DIGOUT_NID
13437
13438 #define alc269_dac_nids         alc260_dac_nids
13439
13440 static hda_nid_t alc269_adc_nids[1] = {
13441         /* ADC1 */
13442         0x08,
13443 };
13444
13445 static hda_nid_t alc269_capsrc_nids[1] = {
13446         0x23,
13447 };
13448
13449 static hda_nid_t alc269vb_adc_nids[1] = {
13450         /* ADC1 */
13451         0x09,
13452 };
13453
13454 static hda_nid_t alc269vb_capsrc_nids[1] = {
13455         0x22,
13456 };
13457
13458 static hda_nid_t alc269_adc_candidates[] = {
13459         0x08, 0x09, 0x07,
13460 };
13461
13462 #define alc269_modes            alc260_modes
13463 #define alc269_capture_source   alc880_lg_lw_capture_source
13464
13465 static struct snd_kcontrol_new alc269_base_mixer[] = {
13466         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13467         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13468         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
13469         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
13470         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13471         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13472         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13473         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13474         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13475         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
13476         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13477         HDA_CODEC_MUTE_MONO("Mono Playback Switch", 0x16, 2, 0x0, HDA_OUTPUT),
13478         { } /* end */
13479 };
13480
13481 static struct snd_kcontrol_new alc269_quanta_fl1_mixer[] = {
13482         /* output mixer control */
13483         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13484         {
13485                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13486                 .name = "Master Playback Switch",
13487                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13488                 .info = snd_hda_mixer_amp_switch_info,
13489                 .get = snd_hda_mixer_amp_switch_get,
13490                 .put = alc268_acer_master_sw_put,
13491                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13492         },
13493         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13494         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13495         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13496         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13497         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13498         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13499         { }
13500 };
13501
13502 static struct snd_kcontrol_new alc269_lifebook_mixer[] = {
13503         /* output mixer control */
13504         HDA_BIND_VOL("Master Playback Volume", &alc268_acer_bind_master_vol),
13505         {
13506                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
13507                 .name = "Master Playback Switch",
13508                 .subdevice = HDA_SUBDEV_AMP_FLAG,
13509                 .info = snd_hda_mixer_amp_switch_info,
13510                 .get = snd_hda_mixer_amp_switch_get,
13511                 .put = alc268_acer_master_sw_put,
13512                 .private_value = HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
13513         },
13514         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
13515         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
13516         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13517         HDA_CODEC_VOLUME("Internal Mic Playback Volume", 0x0b, 0x01, HDA_INPUT),
13518         HDA_CODEC_MUTE("Internal Mic Playback Switch", 0x0b, 0x01, HDA_INPUT),
13519         HDA_CODEC_VOLUME("Internal Mic Boost", 0x19, 0, HDA_INPUT),
13520         HDA_CODEC_VOLUME("Dock Mic Playback Volume", 0x0b, 0x03, HDA_INPUT),
13521         HDA_CODEC_MUTE("Dock Mic Playback Switch", 0x0b, 0x03, HDA_INPUT),
13522         HDA_CODEC_VOLUME("Dock Mic Boost", 0x1b, 0, HDA_INPUT),
13523         { }
13524 };
13525
13526 static struct snd_kcontrol_new alc269_laptop_mixer[] = {
13527         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13528         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13529         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
13530         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13531         { } /* end */
13532 };
13533
13534 static struct snd_kcontrol_new alc269vb_laptop_mixer[] = {
13535         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
13536         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
13537         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
13538         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
13539         { } /* end */
13540 };
13541
13542 /* capture mixer elements */
13543 static struct snd_kcontrol_new alc269_laptop_analog_capture_mixer[] = {
13544         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13545         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13546         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13547         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13548         { } /* end */
13549 };
13550
13551 static struct snd_kcontrol_new alc269_laptop_digital_capture_mixer[] = {
13552         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
13553         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
13554         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13555         { } /* end */
13556 };
13557
13558 static struct snd_kcontrol_new alc269vb_laptop_analog_capture_mixer[] = {
13559         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13560         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13561         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13562         HDA_CODEC_VOLUME("IntMic Boost", 0x19, 0, HDA_INPUT),
13563         { } /* end */
13564 };
13565
13566 static struct snd_kcontrol_new alc269vb_laptop_digital_capture_mixer[] = {
13567         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
13568         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
13569         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
13570         { } /* end */
13571 };
13572
13573 /* FSC amilo */
13574 #define alc269_fujitsu_mixer    alc269_laptop_mixer
13575
13576 static struct hda_verb alc269_quanta_fl1_verbs[] = {
13577         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13578         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13579         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13580         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13581         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13582         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13583         { }
13584 };
13585
13586 static struct hda_verb alc269_lifebook_verbs[] = {
13587         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13588         {0x1a, AC_VERB_SET_CONNECT_SEL, 0x01},
13589         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13590         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13591         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13592         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13593         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13594         {0x1a, AC_VERB_SET_UNSOLICITED_ENABLE, ALC880_HP_EVENT | AC_USRSP_EN},
13595         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13596         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13597         { }
13598 };
13599
13600 /* toggle speaker-output according to the hp-jack state */
13601 static void alc269_quanta_fl1_speaker_automute(struct hda_codec *codec)
13602 {
13603         unsigned int present;
13604         unsigned char bits;
13605
13606         present = snd_hda_jack_detect(codec, 0x15);
13607         bits = present ? HDA_AMP_MUTE : 0;
13608         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13609                                  HDA_AMP_MUTE, bits);
13610         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13611                                  HDA_AMP_MUTE, bits);
13612
13613         snd_hda_codec_write(codec, 0x20, 0,
13614                         AC_VERB_SET_COEF_INDEX, 0x0c);
13615         snd_hda_codec_write(codec, 0x20, 0,
13616                         AC_VERB_SET_PROC_COEF, 0x680);
13617
13618         snd_hda_codec_write(codec, 0x20, 0,
13619                         AC_VERB_SET_COEF_INDEX, 0x0c);
13620         snd_hda_codec_write(codec, 0x20, 0,
13621                         AC_VERB_SET_PROC_COEF, 0x480);
13622 }
13623
13624 /* toggle speaker-output according to the hp-jacks state */
13625 static void alc269_lifebook_speaker_automute(struct hda_codec *codec)
13626 {
13627         unsigned int present;
13628         unsigned char bits;
13629
13630         /* Check laptop headphone socket */
13631         present = snd_hda_jack_detect(codec, 0x15);
13632
13633         /* Check port replicator headphone socket */
13634         present |= snd_hda_jack_detect(codec, 0x1a);
13635
13636         bits = present ? HDA_AMP_MUTE : 0;
13637         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13638                                  HDA_AMP_MUTE, bits);
13639         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13640                                  HDA_AMP_MUTE, bits);
13641
13642         snd_hda_codec_write(codec, 0x20, 0,
13643                         AC_VERB_SET_COEF_INDEX, 0x0c);
13644         snd_hda_codec_write(codec, 0x20, 0,
13645                         AC_VERB_SET_PROC_COEF, 0x680);
13646
13647         snd_hda_codec_write(codec, 0x20, 0,
13648                         AC_VERB_SET_COEF_INDEX, 0x0c);
13649         snd_hda_codec_write(codec, 0x20, 0,
13650                         AC_VERB_SET_PROC_COEF, 0x480);
13651 }
13652
13653 static void alc269_lifebook_mic_autoswitch(struct hda_codec *codec)
13654 {
13655         unsigned int present_laptop;
13656         unsigned int present_dock;
13657
13658         present_laptop  = snd_hda_jack_detect(codec, 0x18);
13659         present_dock    = snd_hda_jack_detect(codec, 0x1b);
13660
13661         /* Laptop mic port overrides dock mic port, design decision */
13662         if (present_dock)
13663                 snd_hda_codec_write(codec, 0x23, 0,
13664                                 AC_VERB_SET_CONNECT_SEL, 0x3);
13665         if (present_laptop)
13666                 snd_hda_codec_write(codec, 0x23, 0,
13667                                 AC_VERB_SET_CONNECT_SEL, 0x0);
13668         if (!present_dock && !present_laptop)
13669                 snd_hda_codec_write(codec, 0x23, 0,
13670                                 AC_VERB_SET_CONNECT_SEL, 0x1);
13671 }
13672
13673 static void alc269_quanta_fl1_unsol_event(struct hda_codec *codec,
13674                                     unsigned int res)
13675 {
13676         switch (res >> 26) {
13677         case ALC880_HP_EVENT:
13678                 alc269_quanta_fl1_speaker_automute(codec);
13679                 break;
13680         case ALC880_MIC_EVENT:
13681                 alc_mic_automute(codec);
13682                 break;
13683         }
13684 }
13685
13686 static void alc269_lifebook_unsol_event(struct hda_codec *codec,
13687                                         unsigned int res)
13688 {
13689         if ((res >> 26) == ALC880_HP_EVENT)
13690                 alc269_lifebook_speaker_automute(codec);
13691         if ((res >> 26) == ALC880_MIC_EVENT)
13692                 alc269_lifebook_mic_autoswitch(codec);
13693 }
13694
13695 static void alc269_quanta_fl1_setup(struct hda_codec *codec)
13696 {
13697         struct alc_spec *spec = codec->spec;
13698         spec->autocfg.hp_pins[0] = 0x15;
13699         spec->autocfg.speaker_pins[0] = 0x14;
13700         spec->ext_mic.pin = 0x18;
13701         spec->ext_mic.mux_idx = 0;
13702         spec->int_mic.pin = 0x19;
13703         spec->int_mic.mux_idx = 1;
13704         spec->auto_mic = 1;
13705 }
13706
13707 static void alc269_quanta_fl1_init_hook(struct hda_codec *codec)
13708 {
13709         alc269_quanta_fl1_speaker_automute(codec);
13710         alc_mic_automute(codec);
13711 }
13712
13713 static void alc269_lifebook_init_hook(struct hda_codec *codec)
13714 {
13715         alc269_lifebook_speaker_automute(codec);
13716         alc269_lifebook_mic_autoswitch(codec);
13717 }
13718
13719 static struct hda_verb alc269_laptop_dmic_init_verbs[] = {
13720         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13721         {0x23, AC_VERB_SET_CONNECT_SEL, 0x05},
13722         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13723         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13724         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13725         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13726         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13727         {}
13728 };
13729
13730 static struct hda_verb alc269_laptop_amic_init_verbs[] = {
13731         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
13732         {0x23, AC_VERB_SET_CONNECT_SEL, 0x01},
13733         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13734         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, (0x701b | (0x00 << 8))},
13735         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13736         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13737         {}
13738 };
13739
13740 static struct hda_verb alc269vb_laptop_dmic_init_verbs[] = {
13741         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13742         {0x22, AC_VERB_SET_CONNECT_SEL, 0x06},
13743         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13744         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13745         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13746         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13747         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13748         {}
13749 };
13750
13751 static struct hda_verb alc269vb_laptop_amic_init_verbs[] = {
13752         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},
13753         {0x22, AC_VERB_SET_CONNECT_SEL, 0x01},
13754         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, 0xb026 },
13755         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, (0x7019 | (0x00 << 8))},
13756         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13757         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
13758         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
13759         {}
13760 };
13761
13762 /* toggle speaker-output according to the hp-jack state */
13763 static void alc269_speaker_automute(struct hda_codec *codec)
13764 {
13765         struct alc_spec *spec = codec->spec;
13766         unsigned int nid = spec->autocfg.hp_pins[0];
13767         unsigned int present;
13768         unsigned char bits;
13769
13770         present = snd_hda_jack_detect(codec, nid);
13771         bits = present ? HDA_AMP_MUTE : 0;
13772         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
13773                                  HDA_AMP_MUTE, bits);
13774         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
13775                                  HDA_AMP_MUTE, bits);
13776 }
13777
13778 /* unsolicited event for HP jack sensing */
13779 static void alc269_laptop_unsol_event(struct hda_codec *codec,
13780                                      unsigned int res)
13781 {
13782         switch (res >> 26) {
13783         case ALC880_HP_EVENT:
13784                 alc269_speaker_automute(codec);
13785                 break;
13786         case ALC880_MIC_EVENT:
13787                 alc_mic_automute(codec);
13788                 break;
13789         }
13790 }
13791
13792 static void alc269_laptop_amic_setup(struct hda_codec *codec)
13793 {
13794         struct alc_spec *spec = codec->spec;
13795         spec->autocfg.hp_pins[0] = 0x15;
13796         spec->autocfg.speaker_pins[0] = 0x14;
13797         spec->ext_mic.pin = 0x18;
13798         spec->ext_mic.mux_idx = 0;
13799         spec->int_mic.pin = 0x19;
13800         spec->int_mic.mux_idx = 1;
13801         spec->auto_mic = 1;
13802 }
13803
13804 static void alc269_laptop_dmic_setup(struct hda_codec *codec)
13805 {
13806         struct alc_spec *spec = codec->spec;
13807         spec->autocfg.hp_pins[0] = 0x15;
13808         spec->autocfg.speaker_pins[0] = 0x14;
13809         spec->ext_mic.pin = 0x18;
13810         spec->ext_mic.mux_idx = 0;
13811         spec->int_mic.pin = 0x12;
13812         spec->int_mic.mux_idx = 5;
13813         spec->auto_mic = 1;
13814 }
13815
13816 static void alc269vb_laptop_amic_setup(struct hda_codec *codec)
13817 {
13818         struct alc_spec *spec = codec->spec;
13819         spec->autocfg.hp_pins[0] = 0x21;
13820         spec->autocfg.speaker_pins[0] = 0x14;
13821         spec->ext_mic.pin = 0x18;
13822         spec->ext_mic.mux_idx = 0;
13823         spec->int_mic.pin = 0x19;
13824         spec->int_mic.mux_idx = 1;
13825         spec->auto_mic = 1;
13826 }
13827
13828 static void alc269vb_laptop_dmic_setup(struct hda_codec *codec)
13829 {
13830         struct alc_spec *spec = codec->spec;
13831         spec->autocfg.hp_pins[0] = 0x21;
13832         spec->autocfg.speaker_pins[0] = 0x14;
13833         spec->ext_mic.pin = 0x18;
13834         spec->ext_mic.mux_idx = 0;
13835         spec->int_mic.pin = 0x12;
13836         spec->int_mic.mux_idx = 6;
13837         spec->auto_mic = 1;
13838 }
13839
13840 static void alc269_laptop_inithook(struct hda_codec *codec)
13841 {
13842         alc269_speaker_automute(codec);
13843         alc_mic_automute(codec);
13844 }
13845
13846 /*
13847  * generic initialization of ADC, input mixers and output mixers
13848  */
13849 static struct hda_verb alc269_init_verbs[] = {
13850         /*
13851          * Unmute ADC0 and set the default input to mic-in
13852          */
13853         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13854
13855         /*
13856          * Set up output mixers (0x02 - 0x03)
13857          */
13858         /* set vol=0 to output mixers */
13859         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13860         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13861
13862         /* set up input amps for analog loopback */
13863         /* Amp Indices: DAC = 0, mixer = 1 */
13864         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13865         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13866         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13867         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13868         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13869         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13870
13871         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13872         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13873         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13874         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13875         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13876         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13877         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13878
13879         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13880         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13881
13882         /* FIXME: use Mux-type input source selection */
13883         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13884         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13885         {0x23, AC_VERB_SET_CONNECT_SEL, 0x00},
13886
13887         /* set EAPD */
13888         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13889         { }
13890 };
13891
13892 static struct hda_verb alc269vb_init_verbs[] = {
13893         /*
13894          * Unmute ADC0 and set the default input to mic-in
13895          */
13896         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13897
13898         /*
13899          * Set up output mixers (0x02 - 0x03)
13900          */
13901         /* set vol=0 to output mixers */
13902         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13903         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
13904
13905         /* set up input amps for analog loopback */
13906         /* Amp Indices: DAC = 0, mixer = 1 */
13907         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13908         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13909         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13910         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13911         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
13912         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
13913
13914         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13915         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
13916         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
13917         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13918         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
13919         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
13921
13922         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13923         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
13924
13925         /* FIXME: use Mux-type input source selection */
13926         /* Mixer elements: 0x18, 19, 1a, 1b, 1d, 0b */
13927         /* Input mixer1: unmute Mic, F-Mic, Line, CD inputs */
13928         {0x22, AC_VERB_SET_CONNECT_SEL, 0x00},
13929
13930         /* set EAPD */
13931         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
13932         { }
13933 };
13934
13935 #define alc269_auto_create_multi_out_ctls \
13936         alc268_auto_create_multi_out_ctls
13937 #define alc269_auto_create_input_ctls \
13938         alc268_auto_create_input_ctls
13939
13940 #ifdef CONFIG_SND_HDA_POWER_SAVE
13941 #define alc269_loopbacks        alc880_loopbacks
13942 #endif
13943
13944 /* pcm configuration: identical with ALC880 */
13945 #define alc269_pcm_analog_playback      alc880_pcm_analog_playback
13946 #define alc269_pcm_analog_capture       alc880_pcm_analog_capture
13947 #define alc269_pcm_digital_playback     alc880_pcm_digital_playback
13948 #define alc269_pcm_digital_capture      alc880_pcm_digital_capture
13949
13950 static struct hda_pcm_stream alc269_44k_pcm_analog_playback = {
13951         .substreams = 1,
13952         .channels_min = 2,
13953         .channels_max = 8,
13954         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13955         /* NID is set in alc_build_pcms */
13956         .ops = {
13957                 .open = alc880_playback_pcm_open,
13958                 .prepare = alc880_playback_pcm_prepare,
13959                 .cleanup = alc880_playback_pcm_cleanup
13960         },
13961 };
13962
13963 static struct hda_pcm_stream alc269_44k_pcm_analog_capture = {
13964         .substreams = 1,
13965         .channels_min = 2,
13966         .channels_max = 2,
13967         .rates = SNDRV_PCM_RATE_44100, /* fixed rate */
13968         /* NID is set in alc_build_pcms */
13969 };
13970
13971 /*
13972  * BIOS auto configuration
13973  */
13974 static int alc269_parse_auto_config(struct hda_codec *codec)
13975 {
13976         struct alc_spec *spec = codec->spec;
13977         int err;
13978         static hda_nid_t alc269_ignore[] = { 0x1d, 0 };
13979
13980         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
13981                                            alc269_ignore);
13982         if (err < 0)
13983                 return err;
13984
13985         err = alc269_auto_create_multi_out_ctls(spec, &spec->autocfg);
13986         if (err < 0)
13987                 return err;
13988         err = alc269_auto_create_input_ctls(codec, &spec->autocfg);
13989         if (err < 0)
13990                 return err;
13991
13992         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
13993
13994         if (spec->autocfg.dig_outs)
13995                 spec->multiout.dig_out_nid = ALC269_DIGOUT_NID;
13996
13997         if (spec->kctls.list)
13998                 add_mixer(spec, spec->kctls.list);
13999
14000         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010) {
14001                 add_verb(spec, alc269vb_init_verbs);
14002                 alc_ssid_check(codec, 0, 0x1b, 0x14, 0x21);
14003         } else {
14004                 add_verb(spec, alc269_init_verbs);
14005                 alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
14006         }
14007
14008         spec->num_mux_defs = 1;
14009         spec->input_mux = &spec->private_imux[0];
14010         fillup_priv_adc_nids(codec, alc269_adc_candidates,
14011                              sizeof(alc269_adc_candidates));
14012
14013         /* set default input source */
14014         snd_hda_codec_write_cache(codec, spec->capsrc_nids[0],
14015                                   0, AC_VERB_SET_CONNECT_SEL,
14016                                   spec->input_mux->items[0].index);
14017
14018         err = alc_auto_add_mic_boost(codec);
14019         if (err < 0)
14020                 return err;
14021
14022         if (!spec->cap_mixer && !spec->no_analog)
14023                 set_capture_mixer(codec);
14024
14025         return 1;
14026 }
14027
14028 #define alc269_auto_init_multi_out      alc268_auto_init_multi_out
14029 #define alc269_auto_init_hp_out         alc268_auto_init_hp_out
14030 #define alc269_auto_init_analog_input   alc882_auto_init_analog_input
14031
14032
14033 /* init callback for auto-configuration model -- overriding the default init */
14034 static void alc269_auto_init(struct hda_codec *codec)
14035 {
14036         struct alc_spec *spec = codec->spec;
14037         alc269_auto_init_multi_out(codec);
14038         alc269_auto_init_hp_out(codec);
14039         alc269_auto_init_analog_input(codec);
14040         if (spec->unsol_event)
14041                 alc_inithook(codec);
14042 }
14043
14044 /*
14045  * configuration and preset
14046  */
14047 static const char *alc269_models[ALC269_MODEL_LAST] = {
14048         [ALC269_BASIC]                  = "basic",
14049         [ALC269_QUANTA_FL1]             = "quanta",
14050         [ALC269_AMIC]                   = "laptop-amic",
14051         [ALC269_DMIC]                   = "laptop-dmic",
14052         [ALC269_FUJITSU]                = "fujitsu",
14053         [ALC269_LIFEBOOK]               = "lifebook",
14054         [ALC269_AUTO]                   = "auto",
14055 };
14056
14057 static struct snd_pci_quirk alc269_cfg_tbl[] = {
14058         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_QUANTA_FL1),
14059         SND_PCI_QUIRK(0x1043, 0x8330, "ASUS Eeepc P703 P900A",
14060                       ALC269_AMIC),
14061         SND_PCI_QUIRK(0x1043, 0x1013, "ASUS N61Da", ALC269VB_AMIC),
14062         SND_PCI_QUIRK(0x1043, 0x1113, "ASUS N63Jn", ALC269VB_AMIC),
14063         SND_PCI_QUIRK(0x1043, 0x1143, "ASUS B53f", ALC269VB_AMIC),
14064         SND_PCI_QUIRK(0x1043, 0x1133, "ASUS UJ20ft", ALC269_AMIC),
14065         SND_PCI_QUIRK(0x1043, 0x1183, "ASUS K72DR", ALC269VB_AMIC),
14066         SND_PCI_QUIRK(0x1043, 0x11b3, "ASUS K52DR", ALC269VB_AMIC),
14067         SND_PCI_QUIRK(0x1043, 0x11e3, "ASUS U33Jc", ALC269VB_AMIC),
14068         SND_PCI_QUIRK(0x1043, 0x1273, "ASUS UL80Jt", ALC269VB_AMIC),
14069         SND_PCI_QUIRK(0x1043, 0x1283, "ASUS U53Jc", ALC269_AMIC),
14070         SND_PCI_QUIRK(0x1043, 0x12b3, "ASUS N82Jv", ALC269_AMIC),
14071         SND_PCI_QUIRK(0x1043, 0x12d3, "ASUS N61Jv", ALC269_AMIC),
14072         SND_PCI_QUIRK(0x1043, 0x13a3, "ASUS UL30Vt", ALC269_AMIC),
14073         SND_PCI_QUIRK(0x1043, 0x1373, "ASUS G73JX", ALC269_AMIC),
14074         SND_PCI_QUIRK(0x1043, 0x1383, "ASUS UJ30Jc", ALC269_AMIC),
14075         SND_PCI_QUIRK(0x1043, 0x13d3, "ASUS N61JA", ALC269_AMIC),
14076         SND_PCI_QUIRK(0x1043, 0x1413, "ASUS UL50", ALC269_AMIC),
14077         SND_PCI_QUIRK(0x1043, 0x1443, "ASUS UL30", ALC269_AMIC),
14078         SND_PCI_QUIRK(0x1043, 0x1453, "ASUS M60Jv", ALC269_AMIC),
14079         SND_PCI_QUIRK(0x1043, 0x1483, "ASUS UL80", ALC269_AMIC),
14080         SND_PCI_QUIRK(0x1043, 0x14f3, "ASUS F83Vf", ALC269_AMIC),
14081         SND_PCI_QUIRK(0x1043, 0x14e3, "ASUS UL20", ALC269_AMIC),
14082         SND_PCI_QUIRK(0x1043, 0x1513, "ASUS UX30", ALC269_AMIC),
14083         SND_PCI_QUIRK(0x1043, 0x1593, "ASUS N51Vn", ALC269_AMIC),
14084         SND_PCI_QUIRK(0x1043, 0x15a3, "ASUS N60Jv", ALC269_AMIC),
14085         SND_PCI_QUIRK(0x1043, 0x15b3, "ASUS N60Dp", ALC269_AMIC),
14086         SND_PCI_QUIRK(0x1043, 0x15c3, "ASUS N70De", ALC269_AMIC),
14087         SND_PCI_QUIRK(0x1043, 0x15e3, "ASUS F83T", ALC269_AMIC),
14088         SND_PCI_QUIRK(0x1043, 0x1643, "ASUS M60J", ALC269_AMIC),
14089         SND_PCI_QUIRK(0x1043, 0x1653, "ASUS U50", ALC269_AMIC),
14090         SND_PCI_QUIRK(0x1043, 0x1693, "ASUS F50N", ALC269_AMIC),
14091         SND_PCI_QUIRK(0x1043, 0x16a3, "ASUS F5Q", ALC269_AMIC),
14092         SND_PCI_QUIRK(0x1043, 0x16e3, "ASUS UX50", ALC269_DMIC),
14093         SND_PCI_QUIRK(0x1043, 0x1723, "ASUS P80", ALC269_AMIC),
14094         SND_PCI_QUIRK(0x1043, 0x1743, "ASUS U80", ALC269_AMIC),
14095         SND_PCI_QUIRK(0x1043, 0x1773, "ASUS U20A", ALC269_AMIC),
14096         SND_PCI_QUIRK(0x1043, 0x1883, "ASUS F81Se", ALC269_AMIC),
14097         SND_PCI_QUIRK(0x1043, 0x831a, "ASUS Eeepc P901",
14098                       ALC269_DMIC),
14099         SND_PCI_QUIRK(0x1043, 0x834a, "ASUS Eeepc S101",
14100                       ALC269_DMIC),
14101         SND_PCI_QUIRK(0x1043, 0x8398, "ASUS P1005HA", ALC269_DMIC),
14102         SND_PCI_QUIRK(0x1043, 0x83ce, "ASUS P1005HA", ALC269_DMIC),
14103         SND_PCI_QUIRK(0x104d, 0x9071, "SONY XTB", ALC269_DMIC),
14104         SND_PCI_QUIRK(0x10cf, 0x1475, "Lifebook ICH9M-based", ALC269_LIFEBOOK),
14105         SND_PCI_QUIRK(0x152d, 0x1778, "Quanta ON1", ALC269_DMIC),
14106         SND_PCI_QUIRK(0x1734, 0x115d, "FSC Amilo", ALC269_FUJITSU),
14107         SND_PCI_QUIRK(0x17aa, 0x3be9, "Quanta Wistron", ALC269_AMIC),
14108         SND_PCI_QUIRK(0x17aa, 0x3bf8, "Quanta FL1", ALC269_AMIC),
14109         SND_PCI_QUIRK(0x17ff, 0x059a, "Quanta EL3", ALC269_DMIC),
14110         SND_PCI_QUIRK(0x17ff, 0x059b, "Quanta JR1", ALC269_DMIC),
14111         {}
14112 };
14113
14114 static struct alc_config_preset alc269_presets[] = {
14115         [ALC269_BASIC] = {
14116                 .mixers = { alc269_base_mixer },
14117                 .init_verbs = { alc269_init_verbs },
14118                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14119                 .dac_nids = alc269_dac_nids,
14120                 .hp_nid = 0x03,
14121                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14122                 .channel_mode = alc269_modes,
14123                 .input_mux = &alc269_capture_source,
14124         },
14125         [ALC269_QUANTA_FL1] = {
14126                 .mixers = { alc269_quanta_fl1_mixer },
14127                 .init_verbs = { alc269_init_verbs, alc269_quanta_fl1_verbs },
14128                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14129                 .dac_nids = alc269_dac_nids,
14130                 .hp_nid = 0x03,
14131                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14132                 .channel_mode = alc269_modes,
14133                 .input_mux = &alc269_capture_source,
14134                 .unsol_event = alc269_quanta_fl1_unsol_event,
14135                 .setup = alc269_quanta_fl1_setup,
14136                 .init_hook = alc269_quanta_fl1_init_hook,
14137         },
14138         [ALC269_AMIC] = {
14139                 .mixers = { alc269_laptop_mixer },
14140                 .cap_mixer = alc269_laptop_analog_capture_mixer,
14141                 .init_verbs = { alc269_init_verbs,
14142                                 alc269_laptop_amic_init_verbs },
14143                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14144                 .dac_nids = alc269_dac_nids,
14145                 .hp_nid = 0x03,
14146                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14147                 .channel_mode = alc269_modes,
14148                 .unsol_event = alc269_laptop_unsol_event,
14149                 .setup = alc269_laptop_amic_setup,
14150                 .init_hook = alc269_laptop_inithook,
14151         },
14152         [ALC269_DMIC] = {
14153                 .mixers = { alc269_laptop_mixer },
14154                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14155                 .init_verbs = { alc269_init_verbs,
14156                                 alc269_laptop_dmic_init_verbs },
14157                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14158                 .dac_nids = alc269_dac_nids,
14159                 .hp_nid = 0x03,
14160                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14161                 .channel_mode = alc269_modes,
14162                 .unsol_event = alc269_laptop_unsol_event,
14163                 .setup = alc269_laptop_dmic_setup,
14164                 .init_hook = alc269_laptop_inithook,
14165         },
14166         [ALC269VB_AMIC] = {
14167                 .mixers = { alc269vb_laptop_mixer },
14168                 .cap_mixer = alc269vb_laptop_analog_capture_mixer,
14169                 .init_verbs = { alc269vb_init_verbs,
14170                                 alc269vb_laptop_amic_init_verbs },
14171                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14172                 .dac_nids = alc269_dac_nids,
14173                 .hp_nid = 0x03,
14174                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14175                 .channel_mode = alc269_modes,
14176                 .unsol_event = alc269_laptop_unsol_event,
14177                 .setup = alc269vb_laptop_amic_setup,
14178                 .init_hook = alc269_laptop_inithook,
14179         },
14180         [ALC269VB_DMIC] = {
14181                 .mixers = { alc269vb_laptop_mixer },
14182                 .cap_mixer = alc269vb_laptop_digital_capture_mixer,
14183                 .init_verbs = { alc269vb_init_verbs,
14184                                 alc269vb_laptop_dmic_init_verbs },
14185                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14186                 .dac_nids = alc269_dac_nids,
14187                 .hp_nid = 0x03,
14188                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14189                 .channel_mode = alc269_modes,
14190                 .unsol_event = alc269_laptop_unsol_event,
14191                 .setup = alc269vb_laptop_dmic_setup,
14192                 .init_hook = alc269_laptop_inithook,
14193         },
14194         [ALC269_FUJITSU] = {
14195                 .mixers = { alc269_fujitsu_mixer },
14196                 .cap_mixer = alc269_laptop_digital_capture_mixer,
14197                 .init_verbs = { alc269_init_verbs,
14198                                 alc269_laptop_dmic_init_verbs },
14199                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14200                 .dac_nids = alc269_dac_nids,
14201                 .hp_nid = 0x03,
14202                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14203                 .channel_mode = alc269_modes,
14204                 .unsol_event = alc269_laptop_unsol_event,
14205                 .setup = alc269_laptop_dmic_setup,
14206                 .init_hook = alc269_laptop_inithook,
14207         },
14208         [ALC269_LIFEBOOK] = {
14209                 .mixers = { alc269_lifebook_mixer },
14210                 .init_verbs = { alc269_init_verbs, alc269_lifebook_verbs },
14211                 .num_dacs = ARRAY_SIZE(alc269_dac_nids),
14212                 .dac_nids = alc269_dac_nids,
14213                 .hp_nid = 0x03,
14214                 .num_channel_mode = ARRAY_SIZE(alc269_modes),
14215                 .channel_mode = alc269_modes,
14216                 .input_mux = &alc269_capture_source,
14217                 .unsol_event = alc269_lifebook_unsol_event,
14218                 .init_hook = alc269_lifebook_init_hook,
14219         },
14220 };
14221
14222 static int patch_alc269(struct hda_codec *codec)
14223 {
14224         struct alc_spec *spec;
14225         int board_config;
14226         int err;
14227         int is_alc269vb = 0;
14228
14229         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
14230         if (spec == NULL)
14231                 return -ENOMEM;
14232
14233         codec->spec = spec;
14234
14235         alc_fix_pll_init(codec, 0x20, 0x04, 15);
14236
14237         if ((alc_read_coef_idx(codec, 0) & 0x00f0) == 0x0010){
14238                 kfree(codec->chip_name);
14239                 codec->chip_name = kstrdup("ALC259", GFP_KERNEL);
14240                 if (!codec->chip_name) {
14241                         alc_free(codec);
14242                         return -ENOMEM;
14243                 }
14244                 is_alc269vb = 1;
14245         }
14246
14247         board_config = snd_hda_check_board_config(codec, ALC269_MODEL_LAST,
14248                                                   alc269_models,
14249                                                   alc269_cfg_tbl);
14250
14251         if (board_config < 0) {
14252                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
14253                        codec->chip_name);
14254                 board_config = ALC269_AUTO;
14255         }
14256
14257         if (board_config == ALC269_AUTO) {
14258                 /* automatic parse from the BIOS config */
14259                 err = alc269_parse_auto_config(codec);
14260                 if (err < 0) {
14261                         alc_free(codec);
14262                         return err;
14263                 } else if (!err) {
14264                         printk(KERN_INFO
14265                                "hda_codec: Cannot set up configuration "
14266                                "from BIOS.  Using base mode...\n");
14267                         board_config = ALC269_BASIC;
14268                 }
14269         }
14270
14271         err = snd_hda_attach_beep_device(codec, 0x1);
14272         if (err < 0) {
14273                 alc_free(codec);
14274                 return err;
14275         }
14276
14277         if (board_config != ALC269_AUTO)
14278                 setup_preset(codec, &alc269_presets[board_config]);
14279
14280         if (board_config == ALC269_QUANTA_FL1) {
14281                 /* Due to a hardware problem on Lenovo Ideadpad, we need to
14282                  * fix the sample rate of analog I/O to 44.1kHz
14283                  */
14284                 spec->stream_analog_playback = &alc269_44k_pcm_analog_playback;
14285                 spec->stream_analog_capture = &alc269_44k_pcm_analog_capture;
14286         } else {
14287                 spec->stream_analog_playback = &alc269_pcm_analog_playback;
14288                 spec->stream_analog_capture = &alc269_pcm_analog_capture;
14289         }
14290         spec->stream_digital_playback = &alc269_pcm_digital_playback;
14291         spec->stream_digital_capture = &alc269_pcm_digital_capture;
14292
14293         if (!spec->adc_nids) { /* wasn't filled automatically? use default */
14294                 if (!is_alc269vb) {
14295                         spec->adc_nids = alc269_adc_nids;
14296                         spec->num_adc_nids = ARRAY_SIZE(alc269_adc_nids);
14297                         spec->capsrc_nids = alc269_capsrc_nids;
14298                 } else {
14299                         spec->adc_nids = alc269vb_adc_nids;
14300                         spec->num_adc_nids = ARRAY_SIZE(alc269vb_adc_nids);
14301                         spec->capsrc_nids = alc269vb_capsrc_nids;
14302                 }
14303         }
14304
14305         if (!spec->cap_mixer)
14306                 set_capture_mixer(codec);
14307         set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
14308
14309         spec->vmaster_nid = 0x02;
14310
14311         codec->patch_ops = alc_patch_ops;
14312         if (board_config == ALC269_AUTO)
14313                 spec->init_hook = alc269_auto_init;
14314 #ifdef CONFIG_SND_HDA_POWER_SAVE
14315         if (!spec->loopback.amplist)
14316                 spec->loopback.amplist = alc269_loopbacks;
14317 #endif
14318
14319         return 0;
14320 }
14321
14322 /*
14323  *  ALC861 channel source setting (2/6 channel selection for 3-stack)
14324  */
14325
14326 /*
14327  * set the path ways for 2 channel output
14328  * need to set the codec line out and mic 1 pin widgets to inputs
14329  */
14330 static struct hda_verb alc861_threestack_ch2_init[] = {
14331         /* set pin widget 1Ah (line in) for input */
14332         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14333         /* set pin widget 18h (mic1/2) for input, for mic also enable
14334          * the vref
14335          */
14336         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14337
14338         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14339 #if 0
14340         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14341         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14342 #endif
14343         { } /* end */
14344 };
14345 /*
14346  * 6ch mode
14347  * need to set the codec line out and mic 1 pin widgets to outputs
14348  */
14349 static struct hda_verb alc861_threestack_ch6_init[] = {
14350         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14351         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14352         /* set pin widget 18h (mic1) for output (CLFE)*/
14353         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14354
14355         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14356         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14357
14358         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14359 #if 0
14360         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14361         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14362 #endif
14363         { } /* end */
14364 };
14365
14366 static struct hda_channel_mode alc861_threestack_modes[2] = {
14367         { 2, alc861_threestack_ch2_init },
14368         { 6, alc861_threestack_ch6_init },
14369 };
14370 /* Set mic1 as input and unmute the mixer */
14371 static struct hda_verb alc861_uniwill_m31_ch2_init[] = {
14372         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14373         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14374         { } /* end */
14375 };
14376 /* Set mic1 as output and mute mixer */
14377 static struct hda_verb alc861_uniwill_m31_ch4_init[] = {
14378         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14379         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14380         { } /* end */
14381 };
14382
14383 static struct hda_channel_mode alc861_uniwill_m31_modes[2] = {
14384         { 2, alc861_uniwill_m31_ch2_init },
14385         { 4, alc861_uniwill_m31_ch4_init },
14386 };
14387
14388 /* Set mic1 and line-in as input and unmute the mixer */
14389 static struct hda_verb alc861_asus_ch2_init[] = {
14390         /* set pin widget 1Ah (line in) for input */
14391         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14392         /* set pin widget 18h (mic1/2) for input, for mic also enable
14393          * the vref
14394          */
14395         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14396
14397         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c },
14398 #if 0
14399         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x01 << 8)) }, /*mic*/
14400         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7000 | (0x02 << 8)) }, /*line-in*/
14401 #endif
14402         { } /* end */
14403 };
14404 /* Set mic1 nad line-in as output and mute mixer */
14405 static struct hda_verb alc861_asus_ch6_init[] = {
14406         /* set pin widget 1Ah (line in) for output (Back Surround)*/
14407         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14408         /* { 0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14409         /* set pin widget 18h (mic1) for output (CLFE)*/
14410         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14411         /* { 0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE }, */
14412         { 0x0c, AC_VERB_SET_CONNECT_SEL, 0x00 },
14413         { 0x0d, AC_VERB_SET_CONNECT_SEL, 0x00 },
14414
14415         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb080 },
14416 #if 0
14417         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x01 << 8)) }, /*mic*/
14418         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, (0x7080 | (0x02 << 8)) }, /*line in*/
14419 #endif
14420         { } /* end */
14421 };
14422
14423 static struct hda_channel_mode alc861_asus_modes[2] = {
14424         { 2, alc861_asus_ch2_init },
14425         { 6, alc861_asus_ch6_init },
14426 };
14427
14428 /* patch-ALC861 */
14429
14430 static struct snd_kcontrol_new alc861_base_mixer[] = {
14431         /* output mixer control */
14432         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14433         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14434         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14435         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14436         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14437
14438         /*Input mixer control */
14439         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14440            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14441         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14442         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14443         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14444         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14445         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14446         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14447         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14448         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14449
14450         { } /* end */
14451 };
14452
14453 static struct snd_kcontrol_new alc861_3ST_mixer[] = {
14454         /* output mixer control */
14455         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14456         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14457         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14458         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14459         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14460
14461         /* Input mixer control */
14462         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14463            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14464         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14465         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14466         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14467         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14468         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14469         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14470         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14471         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14472
14473         {
14474                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14475                 .name = "Channel Mode",
14476                 .info = alc_ch_mode_info,
14477                 .get = alc_ch_mode_get,
14478                 .put = alc_ch_mode_put,
14479                 .private_value = ARRAY_SIZE(alc861_threestack_modes),
14480         },
14481         { } /* end */
14482 };
14483
14484 static struct snd_kcontrol_new alc861_toshiba_mixer[] = {
14485         /* output mixer control */
14486         HDA_CODEC_MUTE("Master Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14487         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14488         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14489
14490         { } /* end */
14491 };
14492
14493 static struct snd_kcontrol_new alc861_uniwill_m31_mixer[] = {
14494         /* output mixer control */
14495         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14496         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14497         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14498         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14499         /*HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT), */
14500
14501         /* Input mixer control */
14502         /* HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14503            HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT), */
14504         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14505         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14506         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14507         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14508         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14509         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14510         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14511         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_INPUT),
14512
14513         {
14514                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14515                 .name = "Channel Mode",
14516                 .info = alc_ch_mode_info,
14517                 .get = alc_ch_mode_get,
14518                 .put = alc_ch_mode_put,
14519                 .private_value = ARRAY_SIZE(alc861_uniwill_m31_modes),
14520         },
14521         { } /* end */
14522 };
14523
14524 static struct snd_kcontrol_new alc861_asus_mixer[] = {
14525         /* output mixer control */
14526         HDA_CODEC_MUTE("Front Playback Switch", 0x03, 0x0, HDA_OUTPUT),
14527         HDA_CODEC_MUTE("Surround Playback Switch", 0x06, 0x0, HDA_OUTPUT),
14528         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x05, 1, 0x0, HDA_OUTPUT),
14529         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x05, 2, 0x0, HDA_OUTPUT),
14530         HDA_CODEC_MUTE("Side Playback Switch", 0x04, 0x0, HDA_OUTPUT),
14531
14532         /* Input mixer control */
14533         HDA_CODEC_VOLUME("Input Playback Volume", 0x15, 0x0, HDA_OUTPUT),
14534         HDA_CODEC_MUTE("Input Playback Switch", 0x15, 0x0, HDA_OUTPUT),
14535         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14536         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14537         HDA_CODEC_VOLUME("Line Playback Volume", 0x15, 0x02, HDA_INPUT),
14538         HDA_CODEC_MUTE("Line Playback Switch", 0x15, 0x02, HDA_INPUT),
14539         HDA_CODEC_VOLUME("Mic Playback Volume", 0x15, 0x01, HDA_INPUT),
14540         HDA_CODEC_MUTE("Mic Playback Switch", 0x15, 0x01, HDA_INPUT),
14541         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x10, 0x01, HDA_OUTPUT),
14542         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1a, 0x03, HDA_OUTPUT),
14543
14544         {
14545                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
14546                 .name = "Channel Mode",
14547                 .info = alc_ch_mode_info,
14548                 .get = alc_ch_mode_get,
14549                 .put = alc_ch_mode_put,
14550                 .private_value = ARRAY_SIZE(alc861_asus_modes),
14551         },
14552         { }
14553 };
14554
14555 /* additional mixer */
14556 static struct snd_kcontrol_new alc861_asus_laptop_mixer[] = {
14557         HDA_CODEC_VOLUME("CD Playback Volume", 0x15, 0x0, HDA_INPUT),
14558         HDA_CODEC_MUTE("CD Playback Switch", 0x15, 0x0, HDA_INPUT),
14559         { }
14560 };
14561
14562 /*
14563  * generic initialization of ADC, input mixers and output mixers
14564  */
14565 static struct hda_verb alc861_base_init_verbs[] = {
14566         /*
14567          * Unmute ADC0 and set the default input to mic-in
14568          */
14569         /* port-A for surround (rear panel) */
14570         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14571         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x00 },
14572         /* port-B for mic-in (rear panel) with vref */
14573         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14574         /* port-C for line-in (rear panel) */
14575         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14576         /* port-D for Front */
14577         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14578         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14579         /* port-E for HP out (front panel) */
14580         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14581         /* route front PCM to HP */
14582         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14583         /* port-F for mic-in (front panel) with vref */
14584         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14585         /* port-G for CLFE (rear panel) */
14586         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14587         { 0x1f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14588         /* port-H for side (rear panel) */
14589         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14590         { 0x20, AC_VERB_SET_CONNECT_SEL, 0x00 },
14591         /* CD-in */
14592         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14593         /* route front mic to ADC1*/
14594         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14595         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14596
14597         /* Unmute DAC0~3 & spdif out*/
14598         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14599         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14600         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14601         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14602         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14603
14604         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14605         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14606         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14607         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14608         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14609
14610         /* Unmute Stereo Mixer 15 */
14611         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14612         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14613         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14614         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14615
14616         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14617         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14618         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14619         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14620         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14621         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14622         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14623         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14624         /* hp used DAC 3 (Front) */
14625         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14626         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14627
14628         { }
14629 };
14630
14631 static struct hda_verb alc861_threestack_init_verbs[] = {
14632         /*
14633          * Unmute ADC0 and set the default input to mic-in
14634          */
14635         /* port-A for surround (rear panel) */
14636         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14637         /* port-B for mic-in (rear panel) with vref */
14638         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14639         /* port-C for line-in (rear panel) */
14640         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14641         /* port-D for Front */
14642         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14643         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14644         /* port-E for HP out (front panel) */
14645         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 },
14646         /* route front PCM to HP */
14647         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14648         /* port-F for mic-in (front panel) with vref */
14649         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14650         /* port-G for CLFE (rear panel) */
14651         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14652         /* port-H for side (rear panel) */
14653         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14654         /* CD-in */
14655         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14656         /* route front mic to ADC1*/
14657         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14658         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14659         /* Unmute DAC0~3 & spdif out*/
14660         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14661         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14662         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14663         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14664         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14665
14666         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14667         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14668         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14669         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14670         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14671
14672         /* Unmute Stereo Mixer 15 */
14673         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14674         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14675         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14676         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14677
14678         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14679         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14680         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14681         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14682         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14683         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14684         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14685         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14686         /* hp used DAC 3 (Front) */
14687         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14688         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14689         { }
14690 };
14691
14692 static struct hda_verb alc861_uniwill_m31_init_verbs[] = {
14693         /*
14694          * Unmute ADC0 and set the default input to mic-in
14695          */
14696         /* port-A for surround (rear panel) */
14697         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14698         /* port-B for mic-in (rear panel) with vref */
14699         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14700         /* port-C for line-in (rear panel) */
14701         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14702         /* port-D for Front */
14703         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14704         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14705         /* port-E for HP out (front panel) */
14706         /* this has to be set to VREF80 */
14707         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14708         /* route front PCM to HP */
14709         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14710         /* port-F for mic-in (front panel) with vref */
14711         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14712         /* port-G for CLFE (rear panel) */
14713         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14714         /* port-H for side (rear panel) */
14715         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
14716         /* CD-in */
14717         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14718         /* route front mic to ADC1*/
14719         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14720         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14721         /* Unmute DAC0~3 & spdif out*/
14722         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14723         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14724         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14725         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14726         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14727
14728         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14729         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14730         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14731         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14732         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14733
14734         /* Unmute Stereo Mixer 15 */
14735         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14736         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14737         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14738         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14739
14740         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14741         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14742         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14743         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14744         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14745         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14746         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14747         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14748         /* hp used DAC 3 (Front) */
14749         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14750         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14751         { }
14752 };
14753
14754 static struct hda_verb alc861_asus_init_verbs[] = {
14755         /*
14756          * Unmute ADC0 and set the default input to mic-in
14757          */
14758         /* port-A for surround (rear panel)
14759          * according to codec#0 this is the HP jack
14760          */
14761         { 0x0e, AC_VERB_SET_PIN_WIDGET_CONTROL, 0xc0 }, /* was 0x00 */
14762         /* route front PCM to HP */
14763         { 0x0e, AC_VERB_SET_CONNECT_SEL, 0x01 },
14764         /* port-B for mic-in (rear panel) with vref */
14765         { 0x0d, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14766         /* port-C for line-in (rear panel) */
14767         { 0x0c, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14768         /* port-D for Front */
14769         { 0x0b, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14770         { 0x0b, AC_VERB_SET_CONNECT_SEL, 0x00 },
14771         /* port-E for HP out (front panel) */
14772         /* this has to be set to VREF80 */
14773         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14774         /* route front PCM to HP */
14775         { 0x0f, AC_VERB_SET_CONNECT_SEL, 0x00 },
14776         /* port-F for mic-in (front panel) with vref */
14777         { 0x10, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x24 },
14778         /* port-G for CLFE (rear panel) */
14779         { 0x1f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14780         /* port-H for side (rear panel) */
14781         { 0x20, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x40 },
14782         /* CD-in */
14783         { 0x11, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x20 },
14784         /* route front mic to ADC1*/
14785         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},
14786         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14787         /* Unmute DAC0~3 & spdif out*/
14788         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14789         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14790         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14791         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14792         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14793         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14794         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14795         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14796         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14797         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14798
14799         /* Unmute Stereo Mixer 15 */
14800         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14801         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14802         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14803         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c}, /* Output 0~12 step */
14804
14805         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14806         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14807         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14808         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14809         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14810         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14811         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14812         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14813         /* hp used DAC 3 (Front) */
14814         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(3)},
14815         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14816         { }
14817 };
14818
14819 /* additional init verbs for ASUS laptops */
14820 static struct hda_verb alc861_asus_laptop_init_verbs[] = {
14821         { 0x0f, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x45 }, /* HP-out */
14822         { 0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2) }, /* mute line-in */
14823         { }
14824 };
14825
14826 /*
14827  * generic initialization of ADC, input mixers and output mixers
14828  */
14829 static struct hda_verb alc861_auto_init_verbs[] = {
14830         /*
14831          * Unmute ADC0 and set the default input to mic-in
14832          */
14833         /* {0x08, AC_VERB_SET_CONNECT_SEL, 0x00}, */
14834         {0x08, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14835
14836         /* Unmute DAC0~3 & spdif out*/
14837         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14838         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14839         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14840         {0x06, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
14841         {0x07, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
14842
14843         /* Unmute Mixer 14 (mic) 1c (Line in)*/
14844         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14845         {0x014, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14846         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14847         {0x01c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14848
14849         /* Unmute Stereo Mixer 15 */
14850         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
14851         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
14852         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
14853         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, 0xb00c},
14854
14855         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14856         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14857         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14858         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14859         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14860         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14861         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14862         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14863
14864         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14865         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14866         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14867         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14868         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
14869         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
14870         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
14871         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
14872
14873         {0x08, AC_VERB_SET_CONNECT_SEL, 0x00},  /* set Mic 1 */
14874
14875         { }
14876 };
14877
14878 static struct hda_verb alc861_toshiba_init_verbs[] = {
14879         {0x0f, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
14880
14881         { }
14882 };
14883
14884 /* toggle speaker-output according to the hp-jack state */
14885 static void alc861_toshiba_automute(struct hda_codec *codec)
14886 {
14887         unsigned int present = snd_hda_jack_detect(codec, 0x0f);
14888
14889         snd_hda_codec_amp_stereo(codec, 0x16, HDA_INPUT, 0,
14890                                  HDA_AMP_MUTE, present ? HDA_AMP_MUTE : 0);
14891         snd_hda_codec_amp_stereo(codec, 0x1a, HDA_INPUT, 3,
14892                                  HDA_AMP_MUTE, present ? 0 : HDA_AMP_MUTE);
14893 }
14894
14895 static void alc861_toshiba_unsol_event(struct hda_codec *codec,
14896                                        unsigned int res)
14897 {
14898         if ((res >> 26) == ALC880_HP_EVENT)
14899                 alc861_toshiba_automute(codec);
14900 }
14901
14902 /* pcm configuration: identical with ALC880 */
14903 #define alc861_pcm_analog_playback      alc880_pcm_analog_playback
14904 #define alc861_pcm_analog_capture       alc880_pcm_analog_capture
14905 #define alc861_pcm_digital_playback     alc880_pcm_digital_playback
14906 #define alc861_pcm_digital_capture      alc880_pcm_digital_capture
14907
14908
14909 #define ALC861_DIGOUT_NID       0x07
14910
14911 static struct hda_channel_mode alc861_8ch_modes[1] = {
14912         { 8, NULL }
14913 };
14914
14915 static hda_nid_t alc861_dac_nids[4] = {
14916         /* front, surround, clfe, side */
14917         0x03, 0x06, 0x05, 0x04
14918 };
14919
14920 static hda_nid_t alc660_dac_nids[3] = {
14921         /* front, clfe, surround */
14922         0x03, 0x05, 0x06
14923 };
14924
14925 static hda_nid_t alc861_adc_nids[1] = {
14926         /* ADC0-2 */
14927         0x08,
14928 };
14929
14930 static struct hda_input_mux alc861_capture_source = {
14931         .num_items = 5,
14932         .items = {
14933                 { "Mic", 0x0 },
14934                 { "Front Mic", 0x3 },
14935                 { "Line", 0x1 },
14936                 { "CD", 0x4 },
14937                 { "Mixer", 0x5 },
14938         },
14939 };
14940
14941 static hda_nid_t alc861_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
14942 {
14943         struct alc_spec *spec = codec->spec;
14944         hda_nid_t mix, srcs[5];
14945         int i, j, num;
14946
14947         if (snd_hda_get_connections(codec, pin, &mix, 1) != 1)
14948                 return 0;
14949         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
14950         if (num < 0)
14951                 return 0;
14952         for (i = 0; i < num; i++) {
14953                 unsigned int type;
14954                 type = get_wcaps_type(get_wcaps(codec, srcs[i]));
14955                 if (type != AC_WID_AUD_OUT)
14956                         continue;
14957                 for (j = 0; j < spec->multiout.num_dacs; j++)
14958                         if (spec->multiout.dac_nids[j] == srcs[i])
14959                                 break;
14960                 if (j >= spec->multiout.num_dacs)
14961                         return srcs[i];
14962         }
14963         return 0;
14964 }
14965
14966 /* fill in the dac_nids table from the parsed pin configuration */
14967 static int alc861_auto_fill_dac_nids(struct hda_codec *codec,
14968                                      const struct auto_pin_cfg *cfg)
14969 {
14970         struct alc_spec *spec = codec->spec;
14971         int i;
14972         hda_nid_t nid, dac;
14973
14974         spec->multiout.dac_nids = spec->private_dac_nids;
14975         for (i = 0; i < cfg->line_outs; i++) {
14976                 nid = cfg->line_out_pins[i];
14977                 dac = alc861_look_for_dac(codec, nid);
14978                 if (!dac)
14979                         continue;
14980                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
14981         }
14982         return 0;
14983 }
14984
14985 static int alc861_create_out_sw(struct hda_codec *codec, const char *pfx,
14986                                 hda_nid_t nid, unsigned int chs)
14987 {
14988         return add_pb_sw_ctrl(codec->spec, ALC_CTL_WIDGET_MUTE, pfx,
14989                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
14990 }
14991
14992 /* add playback controls from the parsed DAC table */
14993 static int alc861_auto_create_multi_out_ctls(struct hda_codec *codec,
14994                                              const struct auto_pin_cfg *cfg)
14995 {
14996         struct alc_spec *spec = codec->spec;
14997         static const char *chname[4] = {
14998                 "Front", "Surround", NULL /*CLFE*/, "Side"
14999         };
15000         hda_nid_t nid;
15001         int i, err;
15002
15003         if (cfg->line_outs == 1) {
15004                 const char *pfx = NULL;
15005                 if (!cfg->hp_outs)
15006                         pfx = "Master";
15007                 else if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
15008                         pfx = "Speaker";
15009                 if (pfx) {
15010                         nid = spec->multiout.dac_nids[0];
15011                         return alc861_create_out_sw(codec, pfx, nid, 3);
15012                 }
15013         }
15014
15015         for (i = 0; i < cfg->line_outs; i++) {
15016                 nid = spec->multiout.dac_nids[i];
15017                 if (!nid)
15018                         continue;
15019                 if (i == 2) {
15020                         /* Center/LFE */
15021                         err = alc861_create_out_sw(codec, "Center", nid, 1);
15022                         if (err < 0)
15023                                 return err;
15024                         err = alc861_create_out_sw(codec, "LFE", nid, 2);
15025                         if (err < 0)
15026                                 return err;
15027                 } else {
15028                         err = alc861_create_out_sw(codec, chname[i], nid, 3);
15029                         if (err < 0)
15030                                 return err;
15031                 }
15032         }
15033         return 0;
15034 }
15035
15036 static int alc861_auto_create_hp_ctls(struct hda_codec *codec, hda_nid_t pin)
15037 {
15038         struct alc_spec *spec = codec->spec;
15039         int err;
15040         hda_nid_t nid;
15041
15042         if (!pin)
15043                 return 0;
15044
15045         if ((pin >= 0x0b && pin <= 0x10) || pin == 0x1f || pin == 0x20) {
15046                 nid = alc861_look_for_dac(codec, pin);
15047                 if (nid) {
15048                         err = alc861_create_out_sw(codec, "Headphone", nid, 3);
15049                         if (err < 0)
15050                                 return err;
15051                         spec->multiout.hp_nid = nid;
15052                 }
15053         }
15054         return 0;
15055 }
15056
15057 /* create playback/capture controls for input pins */
15058 static int alc861_auto_create_input_ctls(struct hda_codec *codec,
15059                                                 const struct auto_pin_cfg *cfg)
15060 {
15061         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x08, 0);
15062 }
15063
15064 static void alc861_auto_set_output_and_unmute(struct hda_codec *codec,
15065                                               hda_nid_t nid,
15066                                               int pin_type, hda_nid_t dac)
15067 {
15068         hda_nid_t mix, srcs[5];
15069         int i, num;
15070
15071         snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
15072                             pin_type);
15073         snd_hda_codec_write(codec, dac, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15074                             AMP_OUT_UNMUTE);
15075         if (snd_hda_get_connections(codec, nid, &mix, 1) != 1)
15076                 return;
15077         num = snd_hda_get_connections(codec, mix, srcs, ARRAY_SIZE(srcs));
15078         if (num < 0)
15079                 return;
15080         for (i = 0; i < num; i++) {
15081                 unsigned int mute;
15082                 if (srcs[i] == dac || srcs[i] == 0x15)
15083                         mute = AMP_IN_UNMUTE(i);
15084                 else
15085                         mute = AMP_IN_MUTE(i);
15086                 snd_hda_codec_write(codec, mix, 0, AC_VERB_SET_AMP_GAIN_MUTE,
15087                                     mute);
15088         }
15089 }
15090
15091 static void alc861_auto_init_multi_out(struct hda_codec *codec)
15092 {
15093         struct alc_spec *spec = codec->spec;
15094         int i;
15095
15096         for (i = 0; i < spec->autocfg.line_outs; i++) {
15097                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
15098                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
15099                 if (nid)
15100                         alc861_auto_set_output_and_unmute(codec, nid, pin_type,
15101                                                           spec->multiout.dac_nids[i]);
15102         }
15103 }
15104
15105 static void alc861_auto_init_hp_out(struct hda_codec *codec)
15106 {
15107         struct alc_spec *spec = codec->spec;
15108
15109         if (spec->autocfg.hp_outs)
15110                 alc861_auto_set_output_and_unmute(codec,
15111                                                   spec->autocfg.hp_pins[0],
15112                                                   PIN_HP,
15113                                                   spec->multiout.hp_nid);
15114         if (spec->autocfg.speaker_outs)
15115                 alc861_auto_set_output_and_unmute(codec,
15116                                                   spec->autocfg.speaker_pins[0],
15117                                                   PIN_OUT,
15118                                                   spec->multiout.dac_nids[0]);
15119 }
15120
15121 static void alc861_auto_init_analog_input(struct hda_codec *codec)
15122 {
15123         struct alc_spec *spec = codec->spec;
15124         int i;
15125
15126         for (i = 0; i < AUTO_PIN_LAST; i++) {
15127                 hda_nid_t nid = spec->autocfg.input_pins[i];
15128                 if (nid >= 0x0c && nid <= 0x11)
15129                         alc_set_input_pin(codec, nid, i);
15130         }
15131 }
15132
15133 /* parse the BIOS configuration and set up the alc_spec */
15134 /* return 1 if successful, 0 if the proper config is not found,
15135  * or a negative error code
15136  */
15137 static int alc861_parse_auto_config(struct hda_codec *codec)
15138 {
15139         struct alc_spec *spec = codec->spec;
15140         int err;
15141         static hda_nid_t alc861_ignore[] = { 0x1d, 0 };
15142
15143         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
15144                                            alc861_ignore);
15145         if (err < 0)
15146                 return err;
15147         if (!spec->autocfg.line_outs)
15148                 return 0; /* can't find valid BIOS pin config */
15149
15150         err = alc861_auto_fill_dac_nids(codec, &spec->autocfg);
15151         if (err < 0)
15152                 return err;
15153         err = alc861_auto_create_multi_out_ctls(codec, &spec->autocfg);
15154         if (err < 0)
15155                 return err;
15156         err = alc861_auto_create_hp_ctls(codec, spec->autocfg.hp_pins[0]);
15157         if (err < 0)
15158                 return err;
15159         err = alc861_auto_create_input_ctls(codec, &spec->autocfg);
15160         if (err < 0)
15161                 return err;
15162
15163         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
15164
15165         if (spec->autocfg.dig_outs)
15166                 spec->multiout.dig_out_nid = ALC861_DIGOUT_NID;
15167
15168         if (spec->kctls.list)
15169                 add_mixer(spec, spec->kctls.list);
15170
15171         add_verb(spec, alc861_auto_init_verbs);
15172
15173         spec->num_mux_defs = 1;
15174         spec->input_mux = &spec->private_imux[0];
15175
15176         spec->adc_nids = alc861_adc_nids;
15177         spec->num_adc_nids = ARRAY_SIZE(alc861_adc_nids);
15178         set_capture_mixer(codec);
15179
15180         alc_ssid_check(codec, 0x0e, 0x0f, 0x0b, 0);
15181
15182         return 1;
15183 }
15184
15185 /* additional initialization for auto-configuration model */
15186 static void alc861_auto_init(struct hda_codec *codec)
15187 {
15188         struct alc_spec *spec = codec->spec;
15189         alc861_auto_init_multi_out(codec);
15190         alc861_auto_init_hp_out(codec);
15191         alc861_auto_init_analog_input(codec);
15192         if (spec->unsol_event)
15193                 alc_inithook(codec);
15194 }
15195
15196 #ifdef CONFIG_SND_HDA_POWER_SAVE
15197 static struct hda_amp_list alc861_loopbacks[] = {
15198         { 0x15, HDA_INPUT, 0 },
15199         { 0x15, HDA_INPUT, 1 },
15200         { 0x15, HDA_INPUT, 2 },
15201         { 0x15, HDA_INPUT, 3 },
15202         { } /* end */
15203 };
15204 #endif
15205
15206
15207 /*
15208  * configuration and preset
15209  */
15210 static const char *alc861_models[ALC861_MODEL_LAST] = {
15211         [ALC861_3ST]            = "3stack",
15212         [ALC660_3ST]            = "3stack-660",
15213         [ALC861_3ST_DIG]        = "3stack-dig",
15214         [ALC861_6ST_DIG]        = "6stack-dig",
15215         [ALC861_UNIWILL_M31]    = "uniwill-m31",
15216         [ALC861_TOSHIBA]        = "toshiba",
15217         [ALC861_ASUS]           = "asus",
15218         [ALC861_ASUS_LAPTOP]    = "asus-laptop",
15219         [ALC861_AUTO]           = "auto",
15220 };
15221
15222 static struct snd_pci_quirk alc861_cfg_tbl[] = {
15223         SND_PCI_QUIRK(0x1043, 0x1205, "ASUS W7J", ALC861_3ST),
15224         SND_PCI_QUIRK(0x1043, 0x1335, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15225         SND_PCI_QUIRK(0x1043, 0x1338, "ASUS F2/3", ALC861_ASUS_LAPTOP),
15226         SND_PCI_QUIRK(0x1043, 0x1393, "ASUS", ALC861_ASUS),
15227         SND_PCI_QUIRK(0x1043, 0x13d7, "ASUS A9rp", ALC861_ASUS_LAPTOP),
15228         SND_PCI_QUIRK(0x1043, 0x81cb, "ASUS P1-AH2", ALC861_3ST_DIG),
15229         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba", ALC861_TOSHIBA),
15230         /* FIXME: the entry below breaks Toshiba A100 (model=auto works!)
15231          *        Any other models that need this preset?
15232          */
15233         /* SND_PCI_QUIRK(0x1179, 0xff10, "Toshiba", ALC861_TOSHIBA), */
15234         SND_PCI_QUIRK(0x1462, 0x7254, "HP dx2200 (MSI MS-7254)", ALC861_3ST),
15235         SND_PCI_QUIRK(0x1462, 0x7297, "HP dx2250 (MSI MS-7297)", ALC861_3ST),
15236         SND_PCI_QUIRK(0x1584, 0x2b01, "Uniwill X40AIx", ALC861_UNIWILL_M31),
15237         SND_PCI_QUIRK(0x1584, 0x9072, "Uniwill m31", ALC861_UNIWILL_M31),
15238         SND_PCI_QUIRK(0x1584, 0x9075, "Airis Praxis N1212", ALC861_ASUS_LAPTOP),
15239         /* FIXME: the below seems conflict */
15240         /* SND_PCI_QUIRK(0x1584, 0x9075, "Uniwill", ALC861_UNIWILL_M31), */
15241         SND_PCI_QUIRK(0x1849, 0x0660, "Asrock 939SLI32", ALC660_3ST),
15242         SND_PCI_QUIRK(0x8086, 0xd600, "Intel", ALC861_3ST),
15243         {}
15244 };
15245
15246 static struct alc_config_preset alc861_presets[] = {
15247         [ALC861_3ST] = {
15248                 .mixers = { alc861_3ST_mixer },
15249                 .init_verbs = { alc861_threestack_init_verbs },
15250                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15251                 .dac_nids = alc861_dac_nids,
15252                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15253                 .channel_mode = alc861_threestack_modes,
15254                 .need_dac_fix = 1,
15255                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15256                 .adc_nids = alc861_adc_nids,
15257                 .input_mux = &alc861_capture_source,
15258         },
15259         [ALC861_3ST_DIG] = {
15260                 .mixers = { alc861_base_mixer },
15261                 .init_verbs = { alc861_threestack_init_verbs },
15262                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15263                 .dac_nids = alc861_dac_nids,
15264                 .dig_out_nid = ALC861_DIGOUT_NID,
15265                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15266                 .channel_mode = alc861_threestack_modes,
15267                 .need_dac_fix = 1,
15268                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15269                 .adc_nids = alc861_adc_nids,
15270                 .input_mux = &alc861_capture_source,
15271         },
15272         [ALC861_6ST_DIG] = {
15273                 .mixers = { alc861_base_mixer },
15274                 .init_verbs = { alc861_base_init_verbs },
15275                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15276                 .dac_nids = alc861_dac_nids,
15277                 .dig_out_nid = ALC861_DIGOUT_NID,
15278                 .num_channel_mode = ARRAY_SIZE(alc861_8ch_modes),
15279                 .channel_mode = alc861_8ch_modes,
15280                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15281                 .adc_nids = alc861_adc_nids,
15282                 .input_mux = &alc861_capture_source,
15283         },
15284         [ALC660_3ST] = {
15285                 .mixers = { alc861_3ST_mixer },
15286                 .init_verbs = { alc861_threestack_init_verbs },
15287                 .num_dacs = ARRAY_SIZE(alc660_dac_nids),
15288                 .dac_nids = alc660_dac_nids,
15289                 .num_channel_mode = ARRAY_SIZE(alc861_threestack_modes),
15290                 .channel_mode = alc861_threestack_modes,
15291                 .need_dac_fix = 1,
15292                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15293                 .adc_nids = alc861_adc_nids,
15294                 .input_mux = &alc861_capture_source,
15295         },
15296         [ALC861_UNIWILL_M31] = {
15297                 .mixers = { alc861_uniwill_m31_mixer },
15298                 .init_verbs = { alc861_uniwill_m31_init_verbs },
15299                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15300                 .dac_nids = alc861_dac_nids,
15301                 .dig_out_nid = ALC861_DIGOUT_NID,
15302                 .num_channel_mode = ARRAY_SIZE(alc861_uniwill_m31_modes),
15303                 .channel_mode = alc861_uniwill_m31_modes,
15304                 .need_dac_fix = 1,
15305                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15306                 .adc_nids = alc861_adc_nids,
15307                 .input_mux = &alc861_capture_source,
15308         },
15309         [ALC861_TOSHIBA] = {
15310                 .mixers = { alc861_toshiba_mixer },
15311                 .init_verbs = { alc861_base_init_verbs,
15312                                 alc861_toshiba_init_verbs },
15313                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15314                 .dac_nids = alc861_dac_nids,
15315                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15316                 .channel_mode = alc883_3ST_2ch_modes,
15317                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15318                 .adc_nids = alc861_adc_nids,
15319                 .input_mux = &alc861_capture_source,
15320                 .unsol_event = alc861_toshiba_unsol_event,
15321                 .init_hook = alc861_toshiba_automute,
15322         },
15323         [ALC861_ASUS] = {
15324                 .mixers = { alc861_asus_mixer },
15325                 .init_verbs = { alc861_asus_init_verbs },
15326                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15327                 .dac_nids = alc861_dac_nids,
15328                 .dig_out_nid = ALC861_DIGOUT_NID,
15329                 .num_channel_mode = ARRAY_SIZE(alc861_asus_modes),
15330                 .channel_mode = alc861_asus_modes,
15331                 .need_dac_fix = 1,
15332                 .hp_nid = 0x06,
15333                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15334                 .adc_nids = alc861_adc_nids,
15335                 .input_mux = &alc861_capture_source,
15336         },
15337         [ALC861_ASUS_LAPTOP] = {
15338                 .mixers = { alc861_toshiba_mixer, alc861_asus_laptop_mixer },
15339                 .init_verbs = { alc861_asus_init_verbs,
15340                                 alc861_asus_laptop_init_verbs },
15341                 .num_dacs = ARRAY_SIZE(alc861_dac_nids),
15342                 .dac_nids = alc861_dac_nids,
15343                 .dig_out_nid = ALC861_DIGOUT_NID,
15344                 .num_channel_mode = ARRAY_SIZE(alc883_3ST_2ch_modes),
15345                 .channel_mode = alc883_3ST_2ch_modes,
15346                 .need_dac_fix = 1,
15347                 .num_adc_nids = ARRAY_SIZE(alc861_adc_nids),
15348                 .adc_nids = alc861_adc_nids,
15349                 .input_mux = &alc861_capture_source,
15350         },
15351 };
15352
15353 /* Pin config fixes */
15354 enum {
15355         PINFIX_FSC_AMILO_PI1505,
15356 };
15357
15358 static struct alc_pincfg alc861_fsc_amilo_pi1505_pinfix[] = {
15359         { 0x0b, 0x0221101f }, /* HP */
15360         { 0x0f, 0x90170310 }, /* speaker */
15361         { }
15362 };
15363
15364 static const struct alc_fixup alc861_fixups[] = {
15365         [PINFIX_FSC_AMILO_PI1505] = {
15366                 .pins = alc861_fsc_amilo_pi1505_pinfix
15367         },
15368 };
15369
15370 static struct snd_pci_quirk alc861_fixup_tbl[] = {
15371         SND_PCI_QUIRK(0x1734, 0x10c7, "FSC Amilo Pi1505", PINFIX_FSC_AMILO_PI1505),
15372         {}
15373 };
15374
15375 static int patch_alc861(struct hda_codec *codec)
15376 {
15377         struct alc_spec *spec;
15378         int board_config;
15379         int err;
15380
15381         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
15382         if (spec == NULL)
15383                 return -ENOMEM;
15384
15385         codec->spec = spec;
15386
15387         board_config = snd_hda_check_board_config(codec, ALC861_MODEL_LAST,
15388                                                   alc861_models,
15389                                                   alc861_cfg_tbl);
15390
15391         if (board_config < 0) {
15392                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
15393                        codec->chip_name);
15394                 board_config = ALC861_AUTO;
15395         }
15396
15397         alc_pick_fixup(codec, alc861_fixup_tbl, alc861_fixups);
15398
15399         if (board_config == ALC861_AUTO) {
15400                 /* automatic parse from the BIOS config */
15401                 err = alc861_parse_auto_config(codec);
15402                 if (err < 0) {
15403                         alc_free(codec);
15404                         return err;
15405                 } else if (!err) {
15406                         printk(KERN_INFO
15407                                "hda_codec: Cannot set up configuration "
15408                                "from BIOS.  Using base mode...\n");
15409                    board_config = ALC861_3ST_DIG;
15410                 }
15411         }
15412
15413         err = snd_hda_attach_beep_device(codec, 0x23);
15414         if (err < 0) {
15415                 alc_free(codec);
15416                 return err;
15417         }
15418
15419         if (board_config != ALC861_AUTO)
15420                 setup_preset(codec, &alc861_presets[board_config]);
15421
15422         spec->stream_analog_playback = &alc861_pcm_analog_playback;
15423         spec->stream_analog_capture = &alc861_pcm_analog_capture;
15424
15425         spec->stream_digital_playback = &alc861_pcm_digital_playback;
15426         spec->stream_digital_capture = &alc861_pcm_digital_capture;
15427
15428         if (!spec->cap_mixer)
15429                 set_capture_mixer(codec);
15430         set_beep_amp(spec, 0x23, 0, HDA_OUTPUT);
15431
15432         spec->vmaster_nid = 0x03;
15433
15434         codec->patch_ops = alc_patch_ops;
15435         if (board_config == ALC861_AUTO) {
15436                 spec->init_hook = alc861_auto_init;
15437 #ifdef CONFIG_SND_HDA_POWER_SAVE
15438                 spec->power_hook = alc_power_eapd;
15439 #endif
15440         }
15441 #ifdef CONFIG_SND_HDA_POWER_SAVE
15442         if (!spec->loopback.amplist)
15443                 spec->loopback.amplist = alc861_loopbacks;
15444 #endif
15445
15446         return 0;
15447 }
15448
15449 /*
15450  * ALC861-VD support
15451  *
15452  * Based on ALC882
15453  *
15454  * In addition, an independent DAC
15455  */
15456 #define ALC861VD_DIGOUT_NID     0x06
15457
15458 static hda_nid_t alc861vd_dac_nids[4] = {
15459         /* front, surr, clfe, side surr */
15460         0x02, 0x03, 0x04, 0x05
15461 };
15462
15463 /* dac_nids for ALC660vd are in a different order - according to
15464  * Realtek's driver.
15465  * This should probably result in a different mixer for 6stack models
15466  * of ALC660vd codecs, but for now there is only 3stack mixer
15467  * - and it is the same as in 861vd.
15468  * adc_nids in ALC660vd are (is) the same as in 861vd
15469  */
15470 static hda_nid_t alc660vd_dac_nids[3] = {
15471         /* front, rear, clfe, rear_surr */
15472         0x02, 0x04, 0x03
15473 };
15474
15475 static hda_nid_t alc861vd_adc_nids[1] = {
15476         /* ADC0 */
15477         0x09,
15478 };
15479
15480 static hda_nid_t alc861vd_capsrc_nids[1] = { 0x22 };
15481
15482 /* input MUX */
15483 /* FIXME: should be a matrix-type input source selection */
15484 static struct hda_input_mux alc861vd_capture_source = {
15485         .num_items = 4,
15486         .items = {
15487                 { "Mic", 0x0 },
15488                 { "Front Mic", 0x1 },
15489                 { "Line", 0x2 },
15490                 { "CD", 0x4 },
15491         },
15492 };
15493
15494 static struct hda_input_mux alc861vd_dallas_capture_source = {
15495         .num_items = 2,
15496         .items = {
15497                 { "Ext Mic", 0x0 },
15498                 { "Int Mic", 0x1 },
15499         },
15500 };
15501
15502 static struct hda_input_mux alc861vd_hp_capture_source = {
15503         .num_items = 2,
15504         .items = {
15505                 { "Front Mic", 0x0 },
15506                 { "ATAPI Mic", 0x1 },
15507         },
15508 };
15509
15510 /*
15511  * 2ch mode
15512  */
15513 static struct hda_channel_mode alc861vd_3stack_2ch_modes[1] = {
15514         { 2, NULL }
15515 };
15516
15517 /*
15518  * 6ch mode
15519  */
15520 static struct hda_verb alc861vd_6stack_ch6_init[] = {
15521         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
15522         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15523         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15524         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15525         { } /* end */
15526 };
15527
15528 /*
15529  * 8ch mode
15530  */
15531 static struct hda_verb alc861vd_6stack_ch8_init[] = {
15532         { 0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15533         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15534         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15535         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
15536         { } /* end */
15537 };
15538
15539 static struct hda_channel_mode alc861vd_6stack_modes[2] = {
15540         { 6, alc861vd_6stack_ch6_init },
15541         { 8, alc861vd_6stack_ch8_init },
15542 };
15543
15544 static struct snd_kcontrol_new alc861vd_chmode_mixer[] = {
15545         {
15546                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
15547                 .name = "Channel Mode",
15548                 .info = alc_ch_mode_info,
15549                 .get = alc_ch_mode_get,
15550                 .put = alc_ch_mode_put,
15551         },
15552         { } /* end */
15553 };
15554
15555 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
15556  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
15557  */
15558 static struct snd_kcontrol_new alc861vd_6st_mixer[] = {
15559         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15560         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15561
15562         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15563         HDA_BIND_MUTE("Surround Playback Switch", 0x0d, 2, HDA_INPUT),
15564
15565         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0,
15566                                 HDA_OUTPUT),
15567         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0,
15568                                 HDA_OUTPUT),
15569         HDA_BIND_MUTE_MONO("Center Playback Switch", 0x0e, 1, 2, HDA_INPUT),
15570         HDA_BIND_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 2, HDA_INPUT),
15571
15572         HDA_CODEC_VOLUME("Side Playback Volume", 0x05, 0x0, HDA_OUTPUT),
15573         HDA_BIND_MUTE("Side Playback Switch", 0x0f, 2, HDA_INPUT),
15574
15575         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15576
15577         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15578         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15579         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15580
15581         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15582         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15583         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15584
15585         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15586         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15587
15588         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15589         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15590
15591         { } /* end */
15592 };
15593
15594 static struct snd_kcontrol_new alc861vd_3st_mixer[] = {
15595         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15596         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15597
15598         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15599
15600         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15601         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15602         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15603
15604         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15605         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15606         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15607
15608         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
15609         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
15610
15611         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15612         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15613
15614         { } /* end */
15615 };
15616
15617 static struct snd_kcontrol_new alc861vd_lenovo_mixer[] = {
15618         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15619         /*HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),*/
15620         HDA_CODEC_MUTE("Front Playback Switch", 0x14, 0x0, HDA_OUTPUT),
15621
15622         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
15623
15624         HDA_CODEC_VOLUME("Mic Boost", 0x18, 0, HDA_INPUT),
15625         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15626         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15627
15628         HDA_CODEC_VOLUME("Front Mic Boost", 0x19, 0, HDA_INPUT),
15629         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15630         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15631
15632         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
15633         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
15634
15635         { } /* end */
15636 };
15637
15638 /* Pin assignment: Speaker=0x14, HP = 0x15,
15639  *                 Ext Mic=0x18, Int Mic = 0x19, CD = 0x1c, PC Beep = 0x1d
15640  */
15641 static struct snd_kcontrol_new alc861vd_dallas_mixer[] = {
15642         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15643         HDA_BIND_MUTE("Speaker Playback Switch", 0x0c, 2, HDA_INPUT),
15644         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15645         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15646         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
15647         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15648         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15649         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
15650         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15651         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15652         { } /* end */
15653 };
15654
15655 /* Pin assignment: Speaker=0x14, Line-out = 0x15,
15656  *                 Front Mic=0x18, ATAPI Mic = 0x19,
15657  */
15658 static struct snd_kcontrol_new alc861vd_hp_mixer[] = {
15659         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
15660         HDA_BIND_MUTE("Front Playback Switch", 0x0c, 2, HDA_INPUT),
15661         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
15662         HDA_BIND_MUTE("Headphone Playback Switch", 0x0d, 2, HDA_INPUT),
15663         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
15664         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
15665         HDA_CODEC_VOLUME("ATAPI Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
15666         HDA_CODEC_MUTE("ATAPI Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
15667
15668         { } /* end */
15669 };
15670
15671 /*
15672  * generic initialization of ADC, input mixers and output mixers
15673  */
15674 static struct hda_verb alc861vd_volume_init_verbs[] = {
15675         /*
15676          * Unmute ADC0 and set the default input to mic-in
15677          */
15678         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15679         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15680
15681         /* Unmute input amps (CD, Line In, Mic 1 & Mic 2) of
15682          * the analog-loopback mixer widget
15683          */
15684         /* Amp Indices: Mic1 = 0, Mic2 = 1, Line1 = 2, Line2 = 3, CD = 4 */
15685         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15686         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15687         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15688         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15689         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15690
15691         /* Capture mixer: unmute Mic, F-Mic, Line, CD inputs */
15692         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15693         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15694         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(2)},
15695         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(4)},
15696
15697         /*
15698          * Set up output mixers (0x02 - 0x05)
15699          */
15700         /* set vol=0 to output mixers */
15701         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15702         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15703         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15704         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15705
15706         /* set up input amps for analog loopback */
15707         /* Amp Indices: DAC = 0, mixer = 1 */
15708         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15709         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15710         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15711         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15712         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15713         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15714         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15715         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15716
15717         { }
15718 };
15719
15720 /*
15721  * 3-stack pin configuration:
15722  * front = 0x14, mic/clfe = 0x18, HP = 0x19, line/surr = 0x1a, f-mic = 0x1b
15723  */
15724 static struct hda_verb alc861vd_3stack_init_verbs[] = {
15725         /*
15726          * Set pin mode and muting
15727          */
15728         /* set front pin widgets 0x14 for output */
15729         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15730         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15731         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15732
15733         /* Mic (rear) pin: input vref at 80% */
15734         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15735         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15736         /* Front Mic pin: input vref at 80% */
15737         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15738         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15739         /* Line In pin: input */
15740         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15741         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15742         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15743         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15744         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15745         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15746         /* CD pin widget for input */
15747         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15748
15749         { }
15750 };
15751
15752 /*
15753  * 6-stack pin configuration:
15754  */
15755 static struct hda_verb alc861vd_6stack_init_verbs[] = {
15756         /*
15757          * Set pin mode and muting
15758          */
15759         /* set front pin widgets 0x14 for output */
15760         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15761         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15762         {0x14, AC_VERB_SET_CONNECT_SEL, 0x00},
15763
15764         /* Rear Pin: output 1 (0x0d) */
15765         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15766         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15767         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
15768         /* CLFE Pin: output 2 (0x0e) */
15769         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15770         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15771         {0x16, AC_VERB_SET_CONNECT_SEL, 0x02},
15772         /* Side Pin: output 3 (0x0f) */
15773         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15774         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15775         {0x17, AC_VERB_SET_CONNECT_SEL, 0x03},
15776
15777         /* Mic (rear) pin: input vref at 80% */
15778         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15779         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15780         /* Front Mic pin: input vref at 80% */
15781         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
15782         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15783         /* Line In pin: input */
15784         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15785         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15786         /* Line-2 In: Headphone output (output 0 - 0x0c) */
15787         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
15788         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15789         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
15790         /* CD pin widget for input */
15791         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15792
15793         { }
15794 };
15795
15796 static struct hda_verb alc861vd_eapd_verbs[] = {
15797         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15798         { }
15799 };
15800
15801 static struct hda_verb alc660vd_eapd_verbs[] = {
15802         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
15803         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
15804         { }
15805 };
15806
15807 static struct hda_verb alc861vd_lenovo_unsol_verbs[] = {
15808         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15809         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15810         {0x0b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(5)},
15811         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15812         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
15813         {}
15814 };
15815
15816 static void alc861vd_lenovo_mic_automute(struct hda_codec *codec)
15817 {
15818         unsigned int present;
15819         unsigned char bits;
15820
15821         present = snd_hda_jack_detect(codec, 0x18);
15822         bits = present ? HDA_AMP_MUTE : 0;
15823
15824         snd_hda_codec_amp_stereo(codec, 0x0b, HDA_INPUT, 1,
15825                                  HDA_AMP_MUTE, bits);
15826 }
15827
15828 static void alc861vd_lenovo_setup(struct hda_codec *codec)
15829 {
15830         struct alc_spec *spec = codec->spec;
15831         spec->autocfg.hp_pins[0] = 0x1b;
15832         spec->autocfg.speaker_pins[0] = 0x14;
15833 }
15834
15835 static void alc861vd_lenovo_init_hook(struct hda_codec *codec)
15836 {
15837         alc_automute_amp(codec);
15838         alc861vd_lenovo_mic_automute(codec);
15839 }
15840
15841 static void alc861vd_lenovo_unsol_event(struct hda_codec *codec,
15842                                         unsigned int res)
15843 {
15844         switch (res >> 26) {
15845         case ALC880_MIC_EVENT:
15846                 alc861vd_lenovo_mic_automute(codec);
15847                 break;
15848         default:
15849                 alc_automute_amp_unsol_event(codec, res);
15850                 break;
15851         }
15852 }
15853
15854 static struct hda_verb alc861vd_dallas_verbs[] = {
15855         {0x02, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15856         {0x03, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15857         {0x04, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15858         {0x05, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO},
15859
15860         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15861         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
15862         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15863         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15864         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15865         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15866         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15867         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(1)},
15868
15869         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15870         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15871         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15872         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15873         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15874         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15875         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
15876         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
15877
15878         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15879         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15880         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF50},
15881         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
15882         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15883         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15884         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15885         {0x1d, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
15886
15887         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
15888         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(3)},
15889         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(2)},
15890         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(4)},
15891
15892         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
15893         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
15894         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
15895
15896         { } /* end */
15897 };
15898
15899 /* toggle speaker-output according to the hp-jack state */
15900 static void alc861vd_dallas_setup(struct hda_codec *codec)
15901 {
15902         struct alc_spec *spec = codec->spec;
15903
15904         spec->autocfg.hp_pins[0] = 0x15;
15905         spec->autocfg.speaker_pins[0] = 0x14;
15906 }
15907
15908 #ifdef CONFIG_SND_HDA_POWER_SAVE
15909 #define alc861vd_loopbacks      alc880_loopbacks
15910 #endif
15911
15912 /* pcm configuration: identical with ALC880 */
15913 #define alc861vd_pcm_analog_playback    alc880_pcm_analog_playback
15914 #define alc861vd_pcm_analog_capture     alc880_pcm_analog_capture
15915 #define alc861vd_pcm_digital_playback   alc880_pcm_digital_playback
15916 #define alc861vd_pcm_digital_capture    alc880_pcm_digital_capture
15917
15918 /*
15919  * configuration and preset
15920  */
15921 static const char *alc861vd_models[ALC861VD_MODEL_LAST] = {
15922         [ALC660VD_3ST]          = "3stack-660",
15923         [ALC660VD_3ST_DIG]      = "3stack-660-digout",
15924         [ALC660VD_ASUS_V1S]     = "asus-v1s",
15925         [ALC861VD_3ST]          = "3stack",
15926         [ALC861VD_3ST_DIG]      = "3stack-digout",
15927         [ALC861VD_6ST_DIG]      = "6stack-digout",
15928         [ALC861VD_LENOVO]       = "lenovo",
15929         [ALC861VD_DALLAS]       = "dallas",
15930         [ALC861VD_HP]           = "hp",
15931         [ALC861VD_AUTO]         = "auto",
15932 };
15933
15934 static struct snd_pci_quirk alc861vd_cfg_tbl[] = {
15935         SND_PCI_QUIRK(0x1019, 0xa88d, "Realtek ALC660 demo", ALC660VD_3ST),
15936         SND_PCI_QUIRK(0x103c, 0x30bf, "HP TX1000", ALC861VD_HP),
15937         SND_PCI_QUIRK(0x1043, 0x12e2, "Asus z35m", ALC660VD_3ST),
15938         /*SND_PCI_QUIRK(0x1043, 0x1339, "Asus G1", ALC660VD_3ST),*/ /* auto */
15939         SND_PCI_QUIRK(0x1043, 0x1633, "Asus V1Sn", ALC660VD_ASUS_V1S),
15940         SND_PCI_QUIRK(0x1043, 0x81e7, "ASUS", ALC660VD_3ST_DIG),
15941         SND_PCI_QUIRK(0x10de, 0x03f0, "Realtek ALC660 demo", ALC660VD_3ST),
15942         SND_PCI_QUIRK(0x1179, 0xff00, "Toshiba A135", ALC861VD_LENOVO),
15943         /*SND_PCI_QUIRK(0x1179, 0xff00, "DALLAS", ALC861VD_DALLAS),*/ /*lenovo*/
15944         SND_PCI_QUIRK(0x1179, 0xff01, "Toshiba A135", ALC861VD_LENOVO),
15945         SND_PCI_QUIRK(0x1179, 0xff03, "Toshiba P205", ALC861VD_LENOVO),
15946         SND_PCI_QUIRK(0x1179, 0xff31, "Toshiba L30-149", ALC861VD_DALLAS),
15947         SND_PCI_QUIRK(0x1565, 0x820d, "Biostar NF61S SE", ALC861VD_6ST_DIG),
15948         SND_PCI_QUIRK_VENDOR(0x17aa, "Lenovo", ALC861VD_LENOVO),
15949         SND_PCI_QUIRK(0x1849, 0x0862, "ASRock K8NF6G-VSTA", ALC861VD_6ST_DIG),
15950         {}
15951 };
15952
15953 static struct alc_config_preset alc861vd_presets[] = {
15954         [ALC660VD_3ST] = {
15955                 .mixers = { alc861vd_3st_mixer },
15956                 .init_verbs = { alc861vd_volume_init_verbs,
15957                                  alc861vd_3stack_init_verbs },
15958                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15959                 .dac_nids = alc660vd_dac_nids,
15960                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15961                 .channel_mode = alc861vd_3stack_2ch_modes,
15962                 .input_mux = &alc861vd_capture_source,
15963         },
15964         [ALC660VD_3ST_DIG] = {
15965                 .mixers = { alc861vd_3st_mixer },
15966                 .init_verbs = { alc861vd_volume_init_verbs,
15967                                  alc861vd_3stack_init_verbs },
15968                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
15969                 .dac_nids = alc660vd_dac_nids,
15970                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15971                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15972                 .channel_mode = alc861vd_3stack_2ch_modes,
15973                 .input_mux = &alc861vd_capture_source,
15974         },
15975         [ALC861VD_3ST] = {
15976                 .mixers = { alc861vd_3st_mixer },
15977                 .init_verbs = { alc861vd_volume_init_verbs,
15978                                  alc861vd_3stack_init_verbs },
15979                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15980                 .dac_nids = alc861vd_dac_nids,
15981                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15982                 .channel_mode = alc861vd_3stack_2ch_modes,
15983                 .input_mux = &alc861vd_capture_source,
15984         },
15985         [ALC861VD_3ST_DIG] = {
15986                 .mixers = { alc861vd_3st_mixer },
15987                 .init_verbs = { alc861vd_volume_init_verbs,
15988                                  alc861vd_3stack_init_verbs },
15989                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
15990                 .dac_nids = alc861vd_dac_nids,
15991                 .dig_out_nid = ALC861VD_DIGOUT_NID,
15992                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
15993                 .channel_mode = alc861vd_3stack_2ch_modes,
15994                 .input_mux = &alc861vd_capture_source,
15995         },
15996         [ALC861VD_6ST_DIG] = {
15997                 .mixers = { alc861vd_6st_mixer, alc861vd_chmode_mixer },
15998                 .init_verbs = { alc861vd_volume_init_verbs,
15999                                 alc861vd_6stack_init_verbs },
16000                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16001                 .dac_nids = alc861vd_dac_nids,
16002                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16003                 .num_channel_mode = ARRAY_SIZE(alc861vd_6stack_modes),
16004                 .channel_mode = alc861vd_6stack_modes,
16005                 .input_mux = &alc861vd_capture_source,
16006         },
16007         [ALC861VD_LENOVO] = {
16008                 .mixers = { alc861vd_lenovo_mixer },
16009                 .init_verbs = { alc861vd_volume_init_verbs,
16010                                 alc861vd_3stack_init_verbs,
16011                                 alc861vd_eapd_verbs,
16012                                 alc861vd_lenovo_unsol_verbs },
16013                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16014                 .dac_nids = alc660vd_dac_nids,
16015                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16016                 .channel_mode = alc861vd_3stack_2ch_modes,
16017                 .input_mux = &alc861vd_capture_source,
16018                 .unsol_event = alc861vd_lenovo_unsol_event,
16019                 .setup = alc861vd_lenovo_setup,
16020                 .init_hook = alc861vd_lenovo_init_hook,
16021         },
16022         [ALC861VD_DALLAS] = {
16023                 .mixers = { alc861vd_dallas_mixer },
16024                 .init_verbs = { alc861vd_dallas_verbs },
16025                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16026                 .dac_nids = alc861vd_dac_nids,
16027                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16028                 .channel_mode = alc861vd_3stack_2ch_modes,
16029                 .input_mux = &alc861vd_dallas_capture_source,
16030                 .unsol_event = alc_automute_amp_unsol_event,
16031                 .setup = alc861vd_dallas_setup,
16032                 .init_hook = alc_automute_amp,
16033         },
16034         [ALC861VD_HP] = {
16035                 .mixers = { alc861vd_hp_mixer },
16036                 .init_verbs = { alc861vd_dallas_verbs, alc861vd_eapd_verbs },
16037                 .num_dacs = ARRAY_SIZE(alc861vd_dac_nids),
16038                 .dac_nids = alc861vd_dac_nids,
16039                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16040                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16041                 .channel_mode = alc861vd_3stack_2ch_modes,
16042                 .input_mux = &alc861vd_hp_capture_source,
16043                 .unsol_event = alc_automute_amp_unsol_event,
16044                 .setup = alc861vd_dallas_setup,
16045                 .init_hook = alc_automute_amp,
16046         },
16047         [ALC660VD_ASUS_V1S] = {
16048                 .mixers = { alc861vd_lenovo_mixer },
16049                 .init_verbs = { alc861vd_volume_init_verbs,
16050                                 alc861vd_3stack_init_verbs,
16051                                 alc861vd_eapd_verbs,
16052                                 alc861vd_lenovo_unsol_verbs },
16053                 .num_dacs = ARRAY_SIZE(alc660vd_dac_nids),
16054                 .dac_nids = alc660vd_dac_nids,
16055                 .dig_out_nid = ALC861VD_DIGOUT_NID,
16056                 .num_channel_mode = ARRAY_SIZE(alc861vd_3stack_2ch_modes),
16057                 .channel_mode = alc861vd_3stack_2ch_modes,
16058                 .input_mux = &alc861vd_capture_source,
16059                 .unsol_event = alc861vd_lenovo_unsol_event,
16060                 .setup = alc861vd_lenovo_setup,
16061                 .init_hook = alc861vd_lenovo_init_hook,
16062         },
16063 };
16064
16065 /*
16066  * BIOS auto configuration
16067  */
16068 static int alc861vd_auto_create_input_ctls(struct hda_codec *codec,
16069                                                 const struct auto_pin_cfg *cfg)
16070 {
16071         return alc_auto_create_input_ctls(codec, cfg, 0x15, 0x09, 0);
16072 }
16073
16074
16075 static void alc861vd_auto_set_output_and_unmute(struct hda_codec *codec,
16076                                 hda_nid_t nid, int pin_type, int dac_idx)
16077 {
16078         alc_set_pin_output(codec, nid, pin_type);
16079 }
16080
16081 static void alc861vd_auto_init_multi_out(struct hda_codec *codec)
16082 {
16083         struct alc_spec *spec = codec->spec;
16084         int i;
16085
16086         for (i = 0; i <= HDA_SIDE; i++) {
16087                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
16088                 int pin_type = get_pin_type(spec->autocfg.line_out_type);
16089                 if (nid)
16090                         alc861vd_auto_set_output_and_unmute(codec, nid,
16091                                                             pin_type, i);
16092         }
16093 }
16094
16095
16096 static void alc861vd_auto_init_hp_out(struct hda_codec *codec)
16097 {
16098         struct alc_spec *spec = codec->spec;
16099         hda_nid_t pin;
16100
16101         pin = spec->autocfg.hp_pins[0];
16102         if (pin) /* connect to front and use dac 0 */
16103                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_HP, 0);
16104         pin = spec->autocfg.speaker_pins[0];
16105         if (pin)
16106                 alc861vd_auto_set_output_and_unmute(codec, pin, PIN_OUT, 0);
16107 }
16108
16109 #define ALC861VD_PIN_CD_NID             ALC880_PIN_CD_NID
16110
16111 static void alc861vd_auto_init_analog_input(struct hda_codec *codec)
16112 {
16113         struct alc_spec *spec = codec->spec;
16114         int i;
16115
16116         for (i = 0; i < AUTO_PIN_LAST; i++) {
16117                 hda_nid_t nid = spec->autocfg.input_pins[i];
16118                 if (alc_is_input_pin(codec, nid)) {
16119                         alc_set_input_pin(codec, nid, i);
16120                         if (nid != ALC861VD_PIN_CD_NID &&
16121                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
16122                                 snd_hda_codec_write(codec, nid, 0,
16123                                                 AC_VERB_SET_AMP_GAIN_MUTE,
16124                                                 AMP_OUT_MUTE);
16125                 }
16126         }
16127 }
16128
16129 #define alc861vd_auto_init_input_src    alc882_auto_init_input_src
16130
16131 #define alc861vd_idx_to_mixer_vol(nid)          ((nid) + 0x02)
16132 #define alc861vd_idx_to_mixer_switch(nid)       ((nid) + 0x0c)
16133
16134 /* add playback controls from the parsed DAC table */
16135 /* Based on ALC880 version. But ALC861VD has separate,
16136  * different NIDs for mute/unmute switch and volume control */
16137 static int alc861vd_auto_create_multi_out_ctls(struct alc_spec *spec,
16138                                              const struct auto_pin_cfg *cfg)
16139 {
16140         static const char *chname[4] = {"Front", "Surround", "CLFE", "Side"};
16141         hda_nid_t nid_v, nid_s;
16142         int i, err;
16143
16144         for (i = 0; i < cfg->line_outs; i++) {
16145                 if (!spec->multiout.dac_nids[i])
16146                         continue;
16147                 nid_v = alc861vd_idx_to_mixer_vol(
16148                                 alc880_dac_to_idx(
16149                                         spec->multiout.dac_nids[i]));
16150                 nid_s = alc861vd_idx_to_mixer_switch(
16151                                 alc880_dac_to_idx(
16152                                         spec->multiout.dac_nids[i]));
16153
16154                 if (i == 2) {
16155                         /* Center/LFE */
16156                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16157                                               "Center",
16158                                           HDA_COMPOSE_AMP_VAL(nid_v, 1, 0,
16159                                                               HDA_OUTPUT));
16160                         if (err < 0)
16161                                 return err;
16162                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL,
16163                                               "LFE",
16164                                           HDA_COMPOSE_AMP_VAL(nid_v, 2, 0,
16165                                                               HDA_OUTPUT));
16166                         if (err < 0)
16167                                 return err;
16168                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16169                                              "Center",
16170                                           HDA_COMPOSE_AMP_VAL(nid_s, 1, 2,
16171                                                               HDA_INPUT));
16172                         if (err < 0)
16173                                 return err;
16174                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE,
16175                                              "LFE",
16176                                           HDA_COMPOSE_AMP_VAL(nid_s, 2, 2,
16177                                                               HDA_INPUT));
16178                         if (err < 0)
16179                                 return err;
16180                 } else {
16181                         const char *pfx;
16182                         if (cfg->line_outs == 1 &&
16183                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
16184                                 if (!cfg->hp_pins)
16185                                         pfx = "Speaker";
16186                                 else
16187                                         pfx = "PCM";
16188                         } else
16189                                 pfx = chname[i];
16190                         err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16191                                           HDA_COMPOSE_AMP_VAL(nid_v, 3, 0,
16192                                                               HDA_OUTPUT));
16193                         if (err < 0)
16194                                 return err;
16195                         if (cfg->line_outs == 1 &&
16196                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
16197                                 pfx = "Speaker";
16198                         err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16199                                           HDA_COMPOSE_AMP_VAL(nid_s, 3, 2,
16200                                                               HDA_INPUT));
16201                         if (err < 0)
16202                                 return err;
16203                 }
16204         }
16205         return 0;
16206 }
16207
16208 /* add playback controls for speaker and HP outputs */
16209 /* Based on ALC880 version. But ALC861VD has separate,
16210  * different NIDs for mute/unmute switch and volume control */
16211 static int alc861vd_auto_create_extra_out(struct alc_spec *spec,
16212                                         hda_nid_t pin, const char *pfx)
16213 {
16214         hda_nid_t nid_v, nid_s;
16215         int err;
16216
16217         if (!pin)
16218                 return 0;
16219
16220         if (alc880_is_fixed_pin(pin)) {
16221                 nid_v = alc880_idx_to_dac(alc880_fixed_pin_idx(pin));
16222                 /* specify the DAC as the extra output */
16223                 if (!spec->multiout.hp_nid)
16224                         spec->multiout.hp_nid = nid_v;
16225                 else
16226                         spec->multiout.extra_out_nid[0] = nid_v;
16227                 /* control HP volume/switch on the output mixer amp */
16228                 nid_v = alc861vd_idx_to_mixer_vol(
16229                                 alc880_fixed_pin_idx(pin));
16230                 nid_s = alc861vd_idx_to_mixer_switch(
16231                                 alc880_fixed_pin_idx(pin));
16232
16233                 err = add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
16234                                   HDA_COMPOSE_AMP_VAL(nid_v, 3, 0, HDA_OUTPUT));
16235                 if (err < 0)
16236                         return err;
16237                 err = add_pb_sw_ctrl(spec, ALC_CTL_BIND_MUTE, pfx,
16238                                   HDA_COMPOSE_AMP_VAL(nid_s, 3, 2, HDA_INPUT));
16239                 if (err < 0)
16240                         return err;
16241         } else if (alc880_is_multi_pin(pin)) {
16242                 /* set manual connection */
16243                 /* we have only a switch on HP-out PIN */
16244                 err = add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
16245                                   HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
16246                 if (err < 0)
16247                         return err;
16248         }
16249         return 0;
16250 }
16251
16252 /* parse the BIOS configuration and set up the alc_spec
16253  * return 1 if successful, 0 if the proper config is not found,
16254  * or a negative error code
16255  * Based on ALC880 version - had to change it to override
16256  * alc880_auto_create_extra_out and alc880_auto_create_multi_out_ctls */
16257 static int alc861vd_parse_auto_config(struct hda_codec *codec)
16258 {
16259         struct alc_spec *spec = codec->spec;
16260         int err;
16261         static hda_nid_t alc861vd_ignore[] = { 0x1d, 0 };
16262
16263         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
16264                                            alc861vd_ignore);
16265         if (err < 0)
16266                 return err;
16267         if (!spec->autocfg.line_outs)
16268                 return 0; /* can't find valid BIOS pin config */
16269
16270         err = alc880_auto_fill_dac_nids(spec, &spec->autocfg);
16271         if (err < 0)
16272                 return err;
16273         err = alc861vd_auto_create_multi_out_ctls(spec, &spec->autocfg);
16274         if (err < 0)
16275                 return err;
16276         err = alc861vd_auto_create_extra_out(spec,
16277                                              spec->autocfg.speaker_pins[0],
16278                                              "Speaker");
16279         if (err < 0)
16280                 return err;
16281         err = alc861vd_auto_create_extra_out(spec,
16282                                              spec->autocfg.hp_pins[0],
16283                                              "Headphone");
16284         if (err < 0)
16285                 return err;
16286         err = alc861vd_auto_create_input_ctls(codec, &spec->autocfg);
16287         if (err < 0)
16288                 return err;
16289
16290         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
16291
16292         if (spec->autocfg.dig_outs)
16293                 spec->multiout.dig_out_nid = ALC861VD_DIGOUT_NID;
16294
16295         if (spec->kctls.list)
16296                 add_mixer(spec, spec->kctls.list);
16297
16298         add_verb(spec, alc861vd_volume_init_verbs);
16299
16300         spec->num_mux_defs = 1;
16301         spec->input_mux = &spec->private_imux[0];
16302
16303         err = alc_auto_add_mic_boost(codec);
16304         if (err < 0)
16305                 return err;
16306
16307         alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
16308
16309         return 1;
16310 }
16311
16312 /* additional initialization for auto-configuration model */
16313 static void alc861vd_auto_init(struct hda_codec *codec)
16314 {
16315         struct alc_spec *spec = codec->spec;
16316         alc861vd_auto_init_multi_out(codec);
16317         alc861vd_auto_init_hp_out(codec);
16318         alc861vd_auto_init_analog_input(codec);
16319         alc861vd_auto_init_input_src(codec);
16320         if (spec->unsol_event)
16321                 alc_inithook(codec);
16322 }
16323
16324 enum {
16325         ALC660VD_FIX_ASUS_GPIO1
16326 };
16327
16328 /* reset GPIO1 */
16329 static const struct hda_verb alc660vd_fix_asus_gpio1_verbs[] = {
16330         {0x01, AC_VERB_SET_GPIO_MASK, 0x03},
16331         {0x01, AC_VERB_SET_GPIO_DIRECTION, 0x01},
16332         {0x01, AC_VERB_SET_GPIO_DATA, 0x01},
16333         { }
16334 };
16335
16336 static const struct alc_fixup alc861vd_fixups[] = {
16337         [ALC660VD_FIX_ASUS_GPIO1] = {
16338                 .verbs = alc660vd_fix_asus_gpio1_verbs,
16339         },
16340 };
16341
16342 static struct snd_pci_quirk alc861vd_fixup_tbl[] = {
16343         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS A7-K", ALC660VD_FIX_ASUS_GPIO1),
16344         {}
16345 };
16346
16347 static int patch_alc861vd(struct hda_codec *codec)
16348 {
16349         struct alc_spec *spec;
16350         int err, board_config;
16351
16352         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
16353         if (spec == NULL)
16354                 return -ENOMEM;
16355
16356         codec->spec = spec;
16357
16358         board_config = snd_hda_check_board_config(codec, ALC861VD_MODEL_LAST,
16359                                                   alc861vd_models,
16360                                                   alc861vd_cfg_tbl);
16361
16362         if (board_config < 0 || board_config >= ALC861VD_MODEL_LAST) {
16363                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
16364                        codec->chip_name);
16365                 board_config = ALC861VD_AUTO;
16366         }
16367
16368         alc_pick_fixup(codec, alc861vd_fixup_tbl, alc861vd_fixups);
16369
16370         if (board_config == ALC861VD_AUTO) {
16371                 /* automatic parse from the BIOS config */
16372                 err = alc861vd_parse_auto_config(codec);
16373                 if (err < 0) {
16374                         alc_free(codec);
16375                         return err;
16376                 } else if (!err) {
16377                         printk(KERN_INFO
16378                                "hda_codec: Cannot set up configuration "
16379                                "from BIOS.  Using base mode...\n");
16380                         board_config = ALC861VD_3ST;
16381                 }
16382         }
16383
16384         err = snd_hda_attach_beep_device(codec, 0x23);
16385         if (err < 0) {
16386                 alc_free(codec);
16387                 return err;
16388         }
16389
16390         if (board_config != ALC861VD_AUTO)
16391                 setup_preset(codec, &alc861vd_presets[board_config]);
16392
16393         if (codec->vendor_id == 0x10ec0660) {
16394                 /* always turn on EAPD */
16395                 add_verb(spec, alc660vd_eapd_verbs);
16396         }
16397
16398         spec->stream_analog_playback = &alc861vd_pcm_analog_playback;
16399         spec->stream_analog_capture = &alc861vd_pcm_analog_capture;
16400
16401         spec->stream_digital_playback = &alc861vd_pcm_digital_playback;
16402         spec->stream_digital_capture = &alc861vd_pcm_digital_capture;
16403
16404         if (!spec->adc_nids) {
16405                 spec->adc_nids = alc861vd_adc_nids;
16406                 spec->num_adc_nids = ARRAY_SIZE(alc861vd_adc_nids);
16407         }
16408         if (!spec->capsrc_nids)
16409                 spec->capsrc_nids = alc861vd_capsrc_nids;
16410
16411         set_capture_mixer(codec);
16412         set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
16413
16414         spec->vmaster_nid = 0x02;
16415
16416         codec->patch_ops = alc_patch_ops;
16417
16418         if (board_config == ALC861VD_AUTO)
16419                 spec->init_hook = alc861vd_auto_init;
16420 #ifdef CONFIG_SND_HDA_POWER_SAVE
16421         if (!spec->loopback.amplist)
16422                 spec->loopback.amplist = alc861vd_loopbacks;
16423 #endif
16424
16425         return 0;
16426 }
16427
16428 /*
16429  * ALC662 support
16430  *
16431  * ALC662 is almost identical with ALC880 but has cleaner and more flexible
16432  * configuration.  Each pin widget can choose any input DACs and a mixer.
16433  * Each ADC is connected from a mixer of all inputs.  This makes possible
16434  * 6-channel independent captures.
16435  *
16436  * In addition, an independent DAC for the multi-playback (not used in this
16437  * driver yet).
16438  */
16439 #define ALC662_DIGOUT_NID       0x06
16440 #define ALC662_DIGIN_NID        0x0a
16441
16442 static hda_nid_t alc662_dac_nids[4] = {
16443         /* front, rear, clfe, rear_surr */
16444         0x02, 0x03, 0x04
16445 };
16446
16447 static hda_nid_t alc272_dac_nids[2] = {
16448         0x02, 0x03
16449 };
16450
16451 static hda_nid_t alc662_adc_nids[2] = {
16452         /* ADC1-2 */
16453         0x09, 0x08
16454 };
16455
16456 static hda_nid_t alc272_adc_nids[1] = {
16457         /* ADC1-2 */
16458         0x08,
16459 };
16460
16461 static hda_nid_t alc662_capsrc_nids[2] = { 0x22, 0x23 };
16462 static hda_nid_t alc272_capsrc_nids[1] = { 0x23 };
16463
16464
16465 /* input MUX */
16466 /* FIXME: should be a matrix-type input source selection */
16467 static struct hda_input_mux alc662_capture_source = {
16468         .num_items = 4,
16469         .items = {
16470                 { "Mic", 0x0 },
16471                 { "Front Mic", 0x1 },
16472                 { "Line", 0x2 },
16473                 { "CD", 0x4 },
16474         },
16475 };
16476
16477 static struct hda_input_mux alc662_lenovo_101e_capture_source = {
16478         .num_items = 2,
16479         .items = {
16480                 { "Mic", 0x1 },
16481                 { "Line", 0x2 },
16482         },
16483 };
16484
16485 static struct hda_input_mux alc663_capture_source = {
16486         .num_items = 3,
16487         .items = {
16488                 { "Mic", 0x0 },
16489                 { "Front Mic", 0x1 },
16490                 { "Line", 0x2 },
16491         },
16492 };
16493
16494 #if 0 /* set to 1 for testing other input sources below */
16495 static struct hda_input_mux alc272_nc10_capture_source = {
16496         .num_items = 16,
16497         .items = {
16498                 { "Autoselect Mic", 0x0 },
16499                 { "Internal Mic", 0x1 },
16500                 { "In-0x02", 0x2 },
16501                 { "In-0x03", 0x3 },
16502                 { "In-0x04", 0x4 },
16503                 { "In-0x05", 0x5 },
16504                 { "In-0x06", 0x6 },
16505                 { "In-0x07", 0x7 },
16506                 { "In-0x08", 0x8 },
16507                 { "In-0x09", 0x9 },
16508                 { "In-0x0a", 0x0a },
16509                 { "In-0x0b", 0x0b },
16510                 { "In-0x0c", 0x0c },
16511                 { "In-0x0d", 0x0d },
16512                 { "In-0x0e", 0x0e },
16513                 { "In-0x0f", 0x0f },
16514         },
16515 };
16516 #endif
16517
16518 /*
16519  * 2ch mode
16520  */
16521 static struct hda_channel_mode alc662_3ST_2ch_modes[1] = {
16522         { 2, NULL }
16523 };
16524
16525 /*
16526  * 2ch mode
16527  */
16528 static struct hda_verb alc662_3ST_ch2_init[] = {
16529         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80 },
16530         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16531         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN },
16532         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE },
16533         { } /* end */
16534 };
16535
16536 /*
16537  * 6ch mode
16538  */
16539 static struct hda_verb alc662_3ST_ch6_init[] = {
16540         { 0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16541         { 0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16542         { 0x18, AC_VERB_SET_CONNECT_SEL, 0x02 },
16543         { 0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16544         { 0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE },
16545         { 0x1a, AC_VERB_SET_CONNECT_SEL, 0x01 },
16546         { } /* end */
16547 };
16548
16549 static struct hda_channel_mode alc662_3ST_6ch_modes[2] = {
16550         { 2, alc662_3ST_ch2_init },
16551         { 6, alc662_3ST_ch6_init },
16552 };
16553
16554 /*
16555  * 2ch mode
16556  */
16557 static struct hda_verb alc662_sixstack_ch6_init[] = {
16558         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16559         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, 0x00 },
16560         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16561         { } /* end */
16562 };
16563
16564 /*
16565  * 6ch mode
16566  */
16567 static struct hda_verb alc662_sixstack_ch8_init[] = {
16568         { 0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16569         { 0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16570         { 0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT },
16571         { } /* end */
16572 };
16573
16574 static struct hda_channel_mode alc662_5stack_modes[2] = {
16575         { 2, alc662_sixstack_ch6_init },
16576         { 6, alc662_sixstack_ch8_init },
16577 };
16578
16579 /* Pin assignment: Front=0x14, Rear=0x15, CLFE=0x16, Side=0x17
16580  *                 Mic=0x18, Front Mic=0x19, Line-In=0x1a, HP=0x1b
16581  */
16582
16583 static struct snd_kcontrol_new alc662_base_mixer[] = {
16584         /* output mixer control */
16585         HDA_CODEC_VOLUME("Front Playback Volume", 0x2, 0x0, HDA_OUTPUT),
16586         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16587         HDA_CODEC_VOLUME("Surround Playback Volume", 0x3, 0x0, HDA_OUTPUT),
16588         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16589         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16590         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16591         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16592         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16593         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16594
16595         /*Input mixer control */
16596         HDA_CODEC_VOLUME("CD Playback Volume", 0xb, 0x4, HDA_INPUT),
16597         HDA_CODEC_MUTE("CD Playback Switch", 0xb, 0x4, HDA_INPUT),
16598         HDA_CODEC_VOLUME("Line Playback Volume", 0xb, 0x02, HDA_INPUT),
16599         HDA_CODEC_MUTE("Line Playback Switch", 0xb, 0x02, HDA_INPUT),
16600         HDA_CODEC_VOLUME("Mic Playback Volume", 0xb, 0x0, HDA_INPUT),
16601         HDA_CODEC_MUTE("Mic Playback Switch", 0xb, 0x0, HDA_INPUT),
16602         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0xb, 0x01, HDA_INPUT),
16603         HDA_CODEC_MUTE("Front Mic Playback Switch", 0xb, 0x01, HDA_INPUT),
16604         { } /* end */
16605 };
16606
16607 static struct snd_kcontrol_new alc662_3ST_2ch_mixer[] = {
16608         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16609         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16610         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16611         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16612         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16613         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16614         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16615         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16616         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16617         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16618         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16619         { } /* end */
16620 };
16621
16622 static struct snd_kcontrol_new alc662_3ST_6ch_mixer[] = {
16623         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16624         HDA_CODEC_MUTE("Front Playback Switch", 0x0c, 0x0, HDA_INPUT),
16625         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16626         HDA_CODEC_MUTE("Surround Playback Switch", 0x0d, 0x0, HDA_INPUT),
16627         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16628         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16629         HDA_CODEC_MUTE_MONO("Center Playback Switch", 0x0e, 1, 0x0, HDA_INPUT),
16630         HDA_CODEC_MUTE_MONO("LFE Playback Switch", 0x0e, 2, 0x0, HDA_INPUT),
16631         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16632         HDA_CODEC_VOLUME("CD Playback Volume", 0x0b, 0x04, HDA_INPUT),
16633         HDA_CODEC_MUTE("CD Playback Switch", 0x0b, 0x04, HDA_INPUT),
16634         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16635         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16636         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16637         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16638         HDA_CODEC_VOLUME("Front Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16639         HDA_CODEC_MUTE("Front Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16640         { } /* end */
16641 };
16642
16643 static struct snd_kcontrol_new alc662_lenovo_101e_mixer[] = {
16644         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16645         HDA_BIND_MUTE("Front Playback Switch", 0x02, 2, HDA_INPUT),
16646         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16647         HDA_BIND_MUTE("Speaker Playback Switch", 0x03, 2, HDA_INPUT),
16648         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16649         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16650         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16651         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16652         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16653         { } /* end */
16654 };
16655
16656 static struct snd_kcontrol_new alc662_eeepc_p701_mixer[] = {
16657         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16658         ALC262_HIPPO_MASTER_SWITCH,
16659
16660         HDA_CODEC_VOLUME("e-Mic Boost", 0x18, 0, HDA_INPUT),
16661         HDA_CODEC_VOLUME("e-Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16662         HDA_CODEC_MUTE("e-Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16663
16664         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
16665         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16666         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16667         { } /* end */
16668 };
16669
16670 static struct snd_kcontrol_new alc662_eeepc_ep20_mixer[] = {
16671         ALC262_HIPPO_MASTER_SWITCH,
16672         HDA_CODEC_VOLUME("Front Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16673         HDA_CODEC_VOLUME("Surround Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16674         HDA_CODEC_VOLUME_MONO("Center Playback Volume", 0x04, 1, 0x0, HDA_OUTPUT),
16675         HDA_CODEC_VOLUME_MONO("LFE Playback Volume", 0x04, 2, 0x0, HDA_OUTPUT),
16676         HDA_BIND_MUTE("MuteCtrl Playback Switch", 0x0c, 2, HDA_INPUT),
16677         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16678         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16679         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16680         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16681         { } /* end */
16682 };
16683
16684 static struct hda_bind_ctls alc663_asus_bind_master_vol = {
16685         .ops = &snd_hda_bind_vol,
16686         .values = {
16687                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16688                 HDA_COMPOSE_AMP_VAL(0x03, 3, 0, HDA_OUTPUT),
16689                 0
16690         },
16691 };
16692
16693 static struct hda_bind_ctls alc663_asus_one_bind_switch = {
16694         .ops = &snd_hda_bind_sw,
16695         .values = {
16696                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16697                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16698                 0
16699         },
16700 };
16701
16702 static struct snd_kcontrol_new alc663_m51va_mixer[] = {
16703         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16704         HDA_BIND_SW("Master Playback Switch", &alc663_asus_one_bind_switch),
16705         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16706         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16707         { } /* end */
16708 };
16709
16710 static struct hda_bind_ctls alc663_asus_tree_bind_switch = {
16711         .ops = &snd_hda_bind_sw,
16712         .values = {
16713                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16714                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16715                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16716                 0
16717         },
16718 };
16719
16720 static struct snd_kcontrol_new alc663_two_hp_m1_mixer[] = {
16721         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16722         HDA_BIND_SW("Master Playback Switch", &alc663_asus_tree_bind_switch),
16723         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16724         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16725         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16726         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16727
16728         { } /* end */
16729 };
16730
16731 static struct hda_bind_ctls alc663_asus_four_bind_switch = {
16732         .ops = &snd_hda_bind_sw,
16733         .values = {
16734                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16735                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16736                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16737                 0
16738         },
16739 };
16740
16741 static struct snd_kcontrol_new alc663_two_hp_m2_mixer[] = {
16742         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16743         HDA_BIND_SW("Master Playback Switch", &alc663_asus_four_bind_switch),
16744         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16745         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16746         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16747         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16748         { } /* end */
16749 };
16750
16751 static struct snd_kcontrol_new alc662_1bjd_mixer[] = {
16752         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16753         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16754         HDA_CODEC_MUTE("Headphone Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16755         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16756         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16757         HDA_CODEC_VOLUME("F-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16758         HDA_CODEC_MUTE("F-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16759         { } /* end */
16760 };
16761
16762 static struct hda_bind_ctls alc663_asus_two_bind_master_vol = {
16763         .ops = &snd_hda_bind_vol,
16764         .values = {
16765                 HDA_COMPOSE_AMP_VAL(0x02, 3, 0, HDA_OUTPUT),
16766                 HDA_COMPOSE_AMP_VAL(0x04, 3, 0, HDA_OUTPUT),
16767                 0
16768         },
16769 };
16770
16771 static struct hda_bind_ctls alc663_asus_two_bind_switch = {
16772         .ops = &snd_hda_bind_sw,
16773         .values = {
16774                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16775                 HDA_COMPOSE_AMP_VAL(0x16, 3, 0, HDA_OUTPUT),
16776                 0
16777         },
16778 };
16779
16780 static struct snd_kcontrol_new alc663_asus_21jd_clfe_mixer[] = {
16781         HDA_BIND_VOL("Master Playback Volume",
16782                                 &alc663_asus_two_bind_master_vol),
16783         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16784         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16785         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16786         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16787         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16788         { } /* end */
16789 };
16790
16791 static struct snd_kcontrol_new alc663_asus_15jd_clfe_mixer[] = {
16792         HDA_BIND_VOL("Master Playback Volume", &alc663_asus_bind_master_vol),
16793         HDA_BIND_SW("Master Playback Switch", &alc663_asus_two_bind_switch),
16794         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16795         HDA_CODEC_MUTE("Headphone Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16796         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16797         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16798         { } /* end */
16799 };
16800
16801 static struct snd_kcontrol_new alc663_g71v_mixer[] = {
16802         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16803         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16804         HDA_CODEC_VOLUME("Front Playback Volume", 0x03, 0x0, HDA_OUTPUT),
16805         HDA_CODEC_MUTE("Front Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16806         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16807
16808         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16809         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16810         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16811         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16812         { } /* end */
16813 };
16814
16815 static struct snd_kcontrol_new alc663_g50v_mixer[] = {
16816         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
16817         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
16818         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16819
16820         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16821         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16822         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16823         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16824         HDA_CODEC_VOLUME("Line Playback Volume", 0x0b, 0x02, HDA_INPUT),
16825         HDA_CODEC_MUTE("Line Playback Switch", 0x0b, 0x02, HDA_INPUT),
16826         { } /* end */
16827 };
16828
16829 static struct hda_bind_ctls alc663_asus_mode7_8_all_bind_switch = {
16830         .ops = &snd_hda_bind_sw,
16831         .values = {
16832                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16833                 HDA_COMPOSE_AMP_VAL(0x15, 3, 0, HDA_OUTPUT),
16834                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16835                 HDA_COMPOSE_AMP_VAL(0x1b, 3, 0, HDA_OUTPUT),
16836                 HDA_COMPOSE_AMP_VAL(0x21, 3, 0, HDA_OUTPUT),
16837                 0
16838         },
16839 };
16840
16841 static struct hda_bind_ctls alc663_asus_mode7_8_sp_bind_switch = {
16842         .ops = &snd_hda_bind_sw,
16843         .values = {
16844                 HDA_COMPOSE_AMP_VAL(0x14, 3, 0, HDA_OUTPUT),
16845                 HDA_COMPOSE_AMP_VAL(0x17, 3, 0, HDA_OUTPUT),
16846                 0
16847         },
16848 };
16849
16850 static struct snd_kcontrol_new alc663_mode7_mixer[] = {
16851         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16852         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16853         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16854         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x1b, 0x0, HDA_OUTPUT),
16855         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16856         HDA_CODEC_VOLUME("IntMic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16857         HDA_CODEC_MUTE("IntMic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16858         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
16859         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
16860         { } /* end */
16861 };
16862
16863 static struct snd_kcontrol_new alc663_mode8_mixer[] = {
16864         HDA_BIND_SW("Master Playback Switch", &alc663_asus_mode7_8_all_bind_switch),
16865         HDA_BIND_VOL("Speaker Playback Volume", &alc663_asus_bind_master_vol),
16866         HDA_BIND_SW("Speaker Playback Switch", &alc663_asus_mode7_8_sp_bind_switch),
16867         HDA_CODEC_MUTE("Headphone1 Playback Switch", 0x15, 0x0, HDA_OUTPUT),
16868         HDA_CODEC_MUTE("Headphone2 Playback Switch", 0x21, 0x0, HDA_OUTPUT),
16869         HDA_CODEC_VOLUME("Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
16870         HDA_CODEC_MUTE("Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
16871         { } /* end */
16872 };
16873
16874
16875 static struct snd_kcontrol_new alc662_chmode_mixer[] = {
16876         {
16877                 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
16878                 .name = "Channel Mode",
16879                 .info = alc_ch_mode_info,
16880                 .get = alc_ch_mode_get,
16881                 .put = alc_ch_mode_put,
16882         },
16883         { } /* end */
16884 };
16885
16886 static struct hda_verb alc662_init_verbs[] = {
16887         /* ADC: mute amp left and right */
16888         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16889         {0x09, AC_VERB_SET_CONNECT_SEL, 0x00},
16890
16891         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16892         {0x0c, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16893         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16894         {0x0d, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16895         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16896         {0x0e, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16897
16898         /* Front Pin: output 0 (0x0c) */
16899         {0x14, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16900         {0x14, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16901
16902         /* Rear Pin: output 1 (0x0d) */
16903         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16904         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16905
16906         /* CLFE Pin: output 2 (0x0e) */
16907         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16908         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16909
16910         /* Mic (rear) pin: input vref at 80% */
16911         {0x18, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16912         {0x18, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16913         /* Front Mic pin: input vref at 80% */
16914         {0x19, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_VREF80},
16915         {0x19, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16916         /* Line In pin: input */
16917         {0x1a, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16918         {0x1a, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16919         /* Line-2 In: Headphone output (output 0 - 0x0c) */
16920         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16921         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16922         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},
16923         /* CD pin widget for input */
16924         {0x1c, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16925
16926         /* FIXME: use matrix-type input source selection */
16927         /* Mixer elements: 0x18, 19, 1a, 1b, 1c, 1d, 14, 15, 16, 17, 0b */
16928         /* Input mixer */
16929         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16930         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16931
16932         /* always trun on EAPD */
16933         {0x14, AC_VERB_SET_EAPD_BTLENABLE, 2},
16934         {0x15, AC_VERB_SET_EAPD_BTLENABLE, 2},
16935
16936         { }
16937 };
16938
16939 static struct hda_verb alc663_init_verbs[] = {
16940         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16941         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16942         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16943         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16944         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16945         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16946         { }
16947 };
16948
16949 static struct hda_verb alc272_init_verbs[] = {
16950         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16951         {0x16, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE},
16952         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16953         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16954         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16955         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16956         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(0)},
16957         {0x0f, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16958         { }
16959 };
16960
16961 static struct hda_verb alc662_sue_init_verbs[] = {
16962         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
16963         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
16964         {}
16965 };
16966
16967 static struct hda_verb alc662_eeepc_sue_init_verbs[] = {
16968         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16969         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16970         {}
16971 };
16972
16973 /* Set Unsolicited Event*/
16974 static struct hda_verb alc662_eeepc_ep20_sue_init_verbs[] = {
16975         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
16976         {0x14, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16977         {}
16978 };
16979
16980 static struct hda_verb alc663_m51va_init_verbs[] = {
16981         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16982         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
16983         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16984         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16985         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16986         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16987         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
16988         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
16989         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
16990         {}
16991 };
16992
16993 static struct hda_verb alc663_21jd_amic_init_verbs[] = {
16994         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
16995         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
16996         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
16997         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
16998         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
16999         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17000         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17001         {}
17002 };
17003
17004 static struct hda_verb alc662_1bjd_amic_init_verbs[] = {
17005         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17006         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17007         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17008         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17009         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17010         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17011         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17012         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17013         {}
17014 };
17015
17016 static struct hda_verb alc663_15jd_amic_init_verbs[] = {
17017         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17018         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17019         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17020         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17021         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17022         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17023         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17024         {}
17025 };
17026
17027 static struct hda_verb alc663_two_hp_amic_m1_init_verbs[] = {
17028         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17029         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17030         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17031         {0x21, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17032         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17033         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17034         {0x15, AC_VERB_SET_CONNECT_SEL, 0x0},   /* Headphone */
17035         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17036         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17037         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17038         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17039         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17040         {}
17041 };
17042
17043 static struct hda_verb alc663_two_hp_amic_m2_init_verbs[] = {
17044         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17045         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17046         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17047         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17048         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17049         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17050         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17051         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17052         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(1)},
17053         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17054         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17055         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17056         {}
17057 };
17058
17059 static struct hda_verb alc663_g71v_init_verbs[] = {
17060         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17061         /* {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE}, */
17062         /* {0x15, AC_VERB_SET_CONNECT_SEL, 0x01}, */ /* Headphone */
17063
17064         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17065         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17066         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17067
17068         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_FRONT_EVENT},
17069         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_MIC_EVENT},
17070         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN|ALC880_HP_EVENT},
17071         {}
17072 };
17073
17074 static struct hda_verb alc663_g50v_init_verbs[] = {
17075         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17076         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17077         {0x21, AC_VERB_SET_CONNECT_SEL, 0x00},  /* Headphone */
17078
17079         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17080         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17081         {}
17082 };
17083
17084 static struct hda_verb alc662_ecs_init_verbs[] = {
17085         {0x09, AC_VERB_SET_AMP_GAIN_MUTE, 0x701f},
17086         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17087         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17088         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17089         {}
17090 };
17091
17092 static struct hda_verb alc272_dell_zm1_init_verbs[] = {
17093         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17094         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17095         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17096         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17097         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17098         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17099         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17100         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17101         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17102         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17103         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17104         {}
17105 };
17106
17107 static struct hda_verb alc272_dell_init_verbs[] = {
17108         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17109         {0x13, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17110         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17111         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17112         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17113         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17114         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17115         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17116         {0x23, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17117         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17118         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17119         {}
17120 };
17121
17122 static struct hda_verb alc663_mode7_init_verbs[] = {
17123         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17124         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17125         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17126         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17127         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17128         {0x1b, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17129         {0x1b, AC_VERB_SET_CONNECT_SEL, 0x01},
17130         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17131         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17132         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17133         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17134         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17135         {0x19, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17136         {0x1b, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17137         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17138         {}
17139 };
17140
17141 static struct hda_verb alc663_mode8_init_verbs[] = {
17142         {0x12, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17143         {0x15, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17144         {0x15, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17145         {0x15, AC_VERB_SET_CONNECT_SEL, 0x01},
17146         {0x16, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17147         {0x17, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT},
17148         {0x17, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17149         {0x1b, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_IN},
17150         {0x21, AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP},
17151         {0x21, AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_UNMUTE},
17152         {0x21, AC_VERB_SET_CONNECT_SEL, 0x01},  /* Headphone */
17153         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_MUTE(0)},
17154         {0x22, AC_VERB_SET_AMP_GAIN_MUTE, AMP_IN_UNMUTE(9)},
17155         {0x15, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17156         {0x18, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_MIC_EVENT},
17157         {0x21, AC_VERB_SET_UNSOLICITED_ENABLE, AC_USRSP_EN | ALC880_HP_EVENT},
17158         {}
17159 };
17160
17161 static struct snd_kcontrol_new alc662_auto_capture_mixer[] = {
17162         HDA_CODEC_VOLUME("Capture Volume", 0x09, 0x0, HDA_INPUT),
17163         HDA_CODEC_MUTE("Capture Switch", 0x09, 0x0, HDA_INPUT),
17164         { } /* end */
17165 };
17166
17167 static struct snd_kcontrol_new alc272_auto_capture_mixer[] = {
17168         HDA_CODEC_VOLUME("Capture Volume", 0x08, 0x0, HDA_INPUT),
17169         HDA_CODEC_MUTE("Capture Switch", 0x08, 0x0, HDA_INPUT),
17170         { } /* end */
17171 };
17172
17173 static void alc662_lenovo_101e_ispeaker_automute(struct hda_codec *codec)
17174 {
17175         unsigned int present;
17176         unsigned char bits;
17177
17178         present = snd_hda_jack_detect(codec, 0x14);
17179         bits = present ? HDA_AMP_MUTE : 0;
17180
17181         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17182                                  HDA_AMP_MUTE, bits);
17183 }
17184
17185 static void alc662_lenovo_101e_all_automute(struct hda_codec *codec)
17186 {
17187         unsigned int present;
17188         unsigned char bits;
17189
17190         present = snd_hda_jack_detect(codec, 0x1b);
17191         bits = present ? HDA_AMP_MUTE : 0;
17192
17193         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17194                                  HDA_AMP_MUTE, bits);
17195         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17196                                  HDA_AMP_MUTE, bits);
17197 }
17198
17199 static void alc662_lenovo_101e_unsol_event(struct hda_codec *codec,
17200                                            unsigned int res)
17201 {
17202         if ((res >> 26) == ALC880_HP_EVENT)
17203                 alc662_lenovo_101e_all_automute(codec);
17204         if ((res >> 26) == ALC880_FRONT_EVENT)
17205                 alc662_lenovo_101e_ispeaker_automute(codec);
17206 }
17207
17208 /* unsolicited event for HP jack sensing */
17209 static void alc662_eeepc_unsol_event(struct hda_codec *codec,
17210                                      unsigned int res)
17211 {
17212         if ((res >> 26) == ALC880_MIC_EVENT)
17213                 alc_mic_automute(codec);
17214         else
17215                 alc262_hippo_unsol_event(codec, res);
17216 }
17217
17218 static void alc662_eeepc_setup(struct hda_codec *codec)
17219 {
17220         struct alc_spec *spec = codec->spec;
17221
17222         alc262_hippo1_setup(codec);
17223         spec->ext_mic.pin = 0x18;
17224         spec->ext_mic.mux_idx = 0;
17225         spec->int_mic.pin = 0x19;
17226         spec->int_mic.mux_idx = 1;
17227         spec->auto_mic = 1;
17228 }
17229
17230 static void alc662_eeepc_inithook(struct hda_codec *codec)
17231 {
17232         alc262_hippo_automute(codec);
17233         alc_mic_automute(codec);
17234 }
17235
17236 static void alc662_eeepc_ep20_setup(struct hda_codec *codec)
17237 {
17238         struct alc_spec *spec = codec->spec;
17239
17240         spec->autocfg.hp_pins[0] = 0x14;
17241         spec->autocfg.speaker_pins[0] = 0x1b;
17242 }
17243
17244 #define alc662_eeepc_ep20_inithook      alc262_hippo_master_update
17245
17246 static void alc663_m51va_speaker_automute(struct hda_codec *codec)
17247 {
17248         unsigned int present;
17249         unsigned char bits;
17250
17251         present = snd_hda_jack_detect(codec, 0x21);
17252         bits = present ? HDA_AMP_MUTE : 0;
17253         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17254                                  HDA_AMP_MUTE, bits);
17255         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17256                                  HDA_AMP_MUTE, bits);
17257 }
17258
17259 static void alc663_21jd_two_speaker_automute(struct hda_codec *codec)
17260 {
17261         unsigned int present;
17262         unsigned char bits;
17263
17264         present = snd_hda_jack_detect(codec, 0x21);
17265         bits = present ? HDA_AMP_MUTE : 0;
17266         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17267                                  HDA_AMP_MUTE, bits);
17268         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17269                                  HDA_AMP_MUTE, bits);
17270         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17271                                  HDA_AMP_MUTE, bits);
17272         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17273                                  HDA_AMP_MUTE, bits);
17274 }
17275
17276 static void alc663_15jd_two_speaker_automute(struct hda_codec *codec)
17277 {
17278         unsigned int present;
17279         unsigned char bits;
17280
17281         present = snd_hda_jack_detect(codec, 0x15);
17282         bits = present ? HDA_AMP_MUTE : 0;
17283         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17284                                  HDA_AMP_MUTE, bits);
17285         snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17286                                  HDA_AMP_MUTE, bits);
17287         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 0,
17288                                  HDA_AMP_MUTE, bits);
17289         snd_hda_codec_amp_stereo(codec, 0x0e, HDA_INPUT, 1,
17290                                  HDA_AMP_MUTE, bits);
17291 }
17292
17293 static void alc662_f5z_speaker_automute(struct hda_codec *codec)
17294 {
17295         unsigned int present;
17296         unsigned char bits;
17297
17298         present = snd_hda_jack_detect(codec, 0x1b);
17299         bits = present ? 0 : PIN_OUT;
17300         snd_hda_codec_write(codec, 0x14, 0,
17301                          AC_VERB_SET_PIN_WIDGET_CONTROL, bits);
17302 }
17303
17304 static void alc663_two_hp_m1_speaker_automute(struct hda_codec *codec)
17305 {
17306         unsigned int present1, present2;
17307
17308         present1 = snd_hda_jack_detect(codec, 0x21);
17309         present2 = snd_hda_jack_detect(codec, 0x15);
17310
17311         if (present1 || present2) {
17312                 snd_hda_codec_write_cache(codec, 0x14, 0,
17313                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17314         } else {
17315                 snd_hda_codec_write_cache(codec, 0x14, 0,
17316                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17317         }
17318 }
17319
17320 static void alc663_two_hp_m2_speaker_automute(struct hda_codec *codec)
17321 {
17322         unsigned int present1, present2;
17323
17324         present1 = snd_hda_jack_detect(codec, 0x1b);
17325         present2 = snd_hda_jack_detect(codec, 0x15);
17326
17327         if (present1 || present2) {
17328                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17329                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17330                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17331                                          HDA_AMP_MUTE, HDA_AMP_MUTE);
17332         } else {
17333                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 0,
17334                                          HDA_AMP_MUTE, 0);
17335                 snd_hda_codec_amp_stereo(codec, 0x0c, HDA_INPUT, 1,
17336                                          HDA_AMP_MUTE, 0);
17337         }
17338 }
17339
17340 static void alc663_two_hp_m7_speaker_automute(struct hda_codec *codec)
17341 {
17342         unsigned int present1, present2;
17343
17344         present1 = snd_hda_codec_read(codec, 0x1b, 0,
17345                         AC_VERB_GET_PIN_SENSE, 0)
17346                         & AC_PINSENSE_PRESENCE;
17347         present2 = snd_hda_codec_read(codec, 0x21, 0,
17348                         AC_VERB_GET_PIN_SENSE, 0)
17349                         & AC_PINSENSE_PRESENCE;
17350
17351         if (present1 || present2) {
17352                 snd_hda_codec_write_cache(codec, 0x14, 0,
17353                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17354                 snd_hda_codec_write_cache(codec, 0x17, 0,
17355                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17356         } else {
17357                 snd_hda_codec_write_cache(codec, 0x14, 0,
17358                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17359                 snd_hda_codec_write_cache(codec, 0x17, 0,
17360                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17361         }
17362 }
17363
17364 static void alc663_two_hp_m8_speaker_automute(struct hda_codec *codec)
17365 {
17366         unsigned int present1, present2;
17367
17368         present1 = snd_hda_codec_read(codec, 0x21, 0,
17369                         AC_VERB_GET_PIN_SENSE, 0)
17370                         & AC_PINSENSE_PRESENCE;
17371         present2 = snd_hda_codec_read(codec, 0x15, 0,
17372                         AC_VERB_GET_PIN_SENSE, 0)
17373                         & AC_PINSENSE_PRESENCE;
17374
17375         if (present1 || present2) {
17376                 snd_hda_codec_write_cache(codec, 0x14, 0,
17377                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17378                 snd_hda_codec_write_cache(codec, 0x17, 0,
17379                         AC_VERB_SET_PIN_WIDGET_CONTROL, 0);
17380         } else {
17381                 snd_hda_codec_write_cache(codec, 0x14, 0,
17382                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17383                 snd_hda_codec_write_cache(codec, 0x17, 0,
17384                         AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
17385         }
17386 }
17387
17388 static void alc663_m51va_unsol_event(struct hda_codec *codec,
17389                                            unsigned int res)
17390 {
17391         switch (res >> 26) {
17392         case ALC880_HP_EVENT:
17393                 alc663_m51va_speaker_automute(codec);
17394                 break;
17395         case ALC880_MIC_EVENT:
17396                 alc_mic_automute(codec);
17397                 break;
17398         }
17399 }
17400
17401 static void alc663_m51va_setup(struct hda_codec *codec)
17402 {
17403         struct alc_spec *spec = codec->spec;
17404         spec->ext_mic.pin = 0x18;
17405         spec->ext_mic.mux_idx = 0;
17406         spec->int_mic.pin = 0x12;
17407         spec->int_mic.mux_idx = 9;
17408         spec->auto_mic = 1;
17409 }
17410
17411 static void alc663_m51va_inithook(struct hda_codec *codec)
17412 {
17413         alc663_m51va_speaker_automute(codec);
17414         alc_mic_automute(codec);
17415 }
17416
17417 /* ***************** Mode1 ******************************/
17418 #define alc663_mode1_unsol_event        alc663_m51va_unsol_event
17419
17420 static void alc663_mode1_setup(struct hda_codec *codec)
17421 {
17422         struct alc_spec *spec = codec->spec;
17423         spec->ext_mic.pin = 0x18;
17424         spec->ext_mic.mux_idx = 0;
17425         spec->int_mic.pin = 0x19;
17426         spec->int_mic.mux_idx = 1;
17427         spec->auto_mic = 1;
17428 }
17429
17430 #define alc663_mode1_inithook           alc663_m51va_inithook
17431
17432 /* ***************** Mode2 ******************************/
17433 static void alc662_mode2_unsol_event(struct hda_codec *codec,
17434                                            unsigned int res)
17435 {
17436         switch (res >> 26) {
17437         case ALC880_HP_EVENT:
17438                 alc662_f5z_speaker_automute(codec);
17439                 break;
17440         case ALC880_MIC_EVENT:
17441                 alc_mic_automute(codec);
17442                 break;
17443         }
17444 }
17445
17446 #define alc662_mode2_setup      alc663_mode1_setup
17447
17448 static void alc662_mode2_inithook(struct hda_codec *codec)
17449 {
17450         alc662_f5z_speaker_automute(codec);
17451         alc_mic_automute(codec);
17452 }
17453 /* ***************** Mode3 ******************************/
17454 static void alc663_mode3_unsol_event(struct hda_codec *codec,
17455                                            unsigned int res)
17456 {
17457         switch (res >> 26) {
17458         case ALC880_HP_EVENT:
17459                 alc663_two_hp_m1_speaker_automute(codec);
17460                 break;
17461         case ALC880_MIC_EVENT:
17462                 alc_mic_automute(codec);
17463                 break;
17464         }
17465 }
17466
17467 #define alc663_mode3_setup      alc663_mode1_setup
17468
17469 static void alc663_mode3_inithook(struct hda_codec *codec)
17470 {
17471         alc663_two_hp_m1_speaker_automute(codec);
17472         alc_mic_automute(codec);
17473 }
17474 /* ***************** Mode4 ******************************/
17475 static void alc663_mode4_unsol_event(struct hda_codec *codec,
17476                                            unsigned int res)
17477 {
17478         switch (res >> 26) {
17479         case ALC880_HP_EVENT:
17480                 alc663_21jd_two_speaker_automute(codec);
17481                 break;
17482         case ALC880_MIC_EVENT:
17483                 alc_mic_automute(codec);
17484                 break;
17485         }
17486 }
17487
17488 #define alc663_mode4_setup      alc663_mode1_setup
17489
17490 static void alc663_mode4_inithook(struct hda_codec *codec)
17491 {
17492         alc663_21jd_two_speaker_automute(codec);
17493         alc_mic_automute(codec);
17494 }
17495 /* ***************** Mode5 ******************************/
17496 static void alc663_mode5_unsol_event(struct hda_codec *codec,
17497                                            unsigned int res)
17498 {
17499         switch (res >> 26) {
17500         case ALC880_HP_EVENT:
17501                 alc663_15jd_two_speaker_automute(codec);
17502                 break;
17503         case ALC880_MIC_EVENT:
17504                 alc_mic_automute(codec);
17505                 break;
17506         }
17507 }
17508
17509 #define alc663_mode5_setup      alc663_mode1_setup
17510
17511 static void alc663_mode5_inithook(struct hda_codec *codec)
17512 {
17513         alc663_15jd_two_speaker_automute(codec);
17514         alc_mic_automute(codec);
17515 }
17516 /* ***************** Mode6 ******************************/
17517 static void alc663_mode6_unsol_event(struct hda_codec *codec,
17518                                            unsigned int res)
17519 {
17520         switch (res >> 26) {
17521         case ALC880_HP_EVENT:
17522                 alc663_two_hp_m2_speaker_automute(codec);
17523                 break;
17524         case ALC880_MIC_EVENT:
17525                 alc_mic_automute(codec);
17526                 break;
17527         }
17528 }
17529
17530 #define alc663_mode6_setup      alc663_mode1_setup
17531
17532 static void alc663_mode6_inithook(struct hda_codec *codec)
17533 {
17534         alc663_two_hp_m2_speaker_automute(codec);
17535         alc_mic_automute(codec);
17536 }
17537
17538 /* ***************** Mode7 ******************************/
17539 static void alc663_mode7_unsol_event(struct hda_codec *codec,
17540                                            unsigned int res)
17541 {
17542         switch (res >> 26) {
17543         case ALC880_HP_EVENT:
17544                 alc663_two_hp_m7_speaker_automute(codec);
17545                 break;
17546         case ALC880_MIC_EVENT:
17547                 alc_mic_automute(codec);
17548                 break;
17549         }
17550 }
17551
17552 #define alc663_mode7_setup      alc663_mode1_setup
17553
17554 static void alc663_mode7_inithook(struct hda_codec *codec)
17555 {
17556         alc663_two_hp_m7_speaker_automute(codec);
17557         alc_mic_automute(codec);
17558 }
17559
17560 /* ***************** Mode8 ******************************/
17561 static void alc663_mode8_unsol_event(struct hda_codec *codec,
17562                                            unsigned int res)
17563 {
17564         switch (res >> 26) {
17565         case ALC880_HP_EVENT:
17566                 alc663_two_hp_m8_speaker_automute(codec);
17567                 break;
17568         case ALC880_MIC_EVENT:
17569                 alc_mic_automute(codec);
17570                 break;
17571         }
17572 }
17573
17574 #define alc663_mode8_setup      alc663_m51va_setup
17575
17576 static void alc663_mode8_inithook(struct hda_codec *codec)
17577 {
17578         alc663_two_hp_m8_speaker_automute(codec);
17579         alc_mic_automute(codec);
17580 }
17581
17582 static void alc663_g71v_hp_automute(struct hda_codec *codec)
17583 {
17584         unsigned int present;
17585         unsigned char bits;
17586
17587         present = snd_hda_jack_detect(codec, 0x21);
17588         bits = present ? HDA_AMP_MUTE : 0;
17589         snd_hda_codec_amp_stereo(codec, 0x15, HDA_OUTPUT, 0,
17590                                  HDA_AMP_MUTE, bits);
17591         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17592                                  HDA_AMP_MUTE, bits);
17593 }
17594
17595 static void alc663_g71v_front_automute(struct hda_codec *codec)
17596 {
17597         unsigned int present;
17598         unsigned char bits;
17599
17600         present = snd_hda_jack_detect(codec, 0x15);
17601         bits = present ? HDA_AMP_MUTE : 0;
17602         snd_hda_codec_amp_stereo(codec, 0x14, HDA_OUTPUT, 0,
17603                                  HDA_AMP_MUTE, bits);
17604 }
17605
17606 static void alc663_g71v_unsol_event(struct hda_codec *codec,
17607                                            unsigned int res)
17608 {
17609         switch (res >> 26) {
17610         case ALC880_HP_EVENT:
17611                 alc663_g71v_hp_automute(codec);
17612                 break;
17613         case ALC880_FRONT_EVENT:
17614                 alc663_g71v_front_automute(codec);
17615                 break;
17616         case ALC880_MIC_EVENT:
17617                 alc_mic_automute(codec);
17618                 break;
17619         }
17620 }
17621
17622 #define alc663_g71v_setup       alc663_m51va_setup
17623
17624 static void alc663_g71v_inithook(struct hda_codec *codec)
17625 {
17626         alc663_g71v_front_automute(codec);
17627         alc663_g71v_hp_automute(codec);
17628         alc_mic_automute(codec);
17629 }
17630
17631 static void alc663_g50v_unsol_event(struct hda_codec *codec,
17632                                            unsigned int res)
17633 {
17634         switch (res >> 26) {
17635         case ALC880_HP_EVENT:
17636                 alc663_m51va_speaker_automute(codec);
17637                 break;
17638         case ALC880_MIC_EVENT:
17639                 alc_mic_automute(codec);
17640                 break;
17641         }
17642 }
17643
17644 #define alc663_g50v_setup       alc663_m51va_setup
17645
17646 static void alc663_g50v_inithook(struct hda_codec *codec)
17647 {
17648         alc663_m51va_speaker_automute(codec);
17649         alc_mic_automute(codec);
17650 }
17651
17652 static struct snd_kcontrol_new alc662_ecs_mixer[] = {
17653         HDA_CODEC_VOLUME("Master Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17654         ALC262_HIPPO_MASTER_SWITCH,
17655
17656         HDA_CODEC_VOLUME("e-Mic/LineIn Boost", 0x18, 0, HDA_INPUT),
17657         HDA_CODEC_VOLUME("e-Mic/LineIn Playback Volume", 0x0b, 0x0, HDA_INPUT),
17658         HDA_CODEC_MUTE("e-Mic/LineIn Playback Switch", 0x0b, 0x0, HDA_INPUT),
17659
17660         HDA_CODEC_VOLUME("i-Mic Boost", 0x19, 0, HDA_INPUT),
17661         HDA_CODEC_VOLUME("i-Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17662         HDA_CODEC_MUTE("i-Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17663         { } /* end */
17664 };
17665
17666 static struct snd_kcontrol_new alc272_nc10_mixer[] = {
17667         /* Master Playback automatically created from Speaker and Headphone */
17668         HDA_CODEC_VOLUME("Speaker Playback Volume", 0x02, 0x0, HDA_OUTPUT),
17669         HDA_CODEC_MUTE("Speaker Playback Switch", 0x14, 0x0, HDA_OUTPUT),
17670         HDA_CODEC_VOLUME("Headphone Playback Volume", 0x03, 0x0, HDA_OUTPUT),
17671         HDA_CODEC_MUTE("Headphone Playback Switch", 0x21, 0x0, HDA_OUTPUT),
17672
17673         HDA_CODEC_VOLUME("Ext Mic Playback Volume", 0x0b, 0x0, HDA_INPUT),
17674         HDA_CODEC_MUTE("Ext Mic Playback Switch", 0x0b, 0x0, HDA_INPUT),
17675         HDA_CODEC_VOLUME("Ext Mic Boost", 0x18, 0, HDA_INPUT),
17676
17677         HDA_CODEC_VOLUME("Int Mic Playback Volume", 0x0b, 0x1, HDA_INPUT),
17678         HDA_CODEC_MUTE("Int Mic Playback Switch", 0x0b, 0x1, HDA_INPUT),
17679         HDA_CODEC_VOLUME("Int Mic Boost", 0x19, 0, HDA_INPUT),
17680         { } /* end */
17681 };
17682
17683 #ifdef CONFIG_SND_HDA_POWER_SAVE
17684 #define alc662_loopbacks        alc880_loopbacks
17685 #endif
17686
17687
17688 /* pcm configuration: identical with ALC880 */
17689 #define alc662_pcm_analog_playback      alc880_pcm_analog_playback
17690 #define alc662_pcm_analog_capture       alc880_pcm_analog_capture
17691 #define alc662_pcm_digital_playback     alc880_pcm_digital_playback
17692 #define alc662_pcm_digital_capture      alc880_pcm_digital_capture
17693
17694 /*
17695  * configuration and preset
17696  */
17697 static const char *alc662_models[ALC662_MODEL_LAST] = {
17698         [ALC662_3ST_2ch_DIG]    = "3stack-dig",
17699         [ALC662_3ST_6ch_DIG]    = "3stack-6ch-dig",
17700         [ALC662_3ST_6ch]        = "3stack-6ch",
17701         [ALC662_5ST_DIG]        = "6stack-dig",
17702         [ALC662_LENOVO_101E]    = "lenovo-101e",
17703         [ALC662_ASUS_EEEPC_P701] = "eeepc-p701",
17704         [ALC662_ASUS_EEEPC_EP20] = "eeepc-ep20",
17705         [ALC662_ECS] = "ecs",
17706         [ALC663_ASUS_M51VA] = "m51va",
17707         [ALC663_ASUS_G71V] = "g71v",
17708         [ALC663_ASUS_H13] = "h13",
17709         [ALC663_ASUS_G50V] = "g50v",
17710         [ALC663_ASUS_MODE1] = "asus-mode1",
17711         [ALC662_ASUS_MODE2] = "asus-mode2",
17712         [ALC663_ASUS_MODE3] = "asus-mode3",
17713         [ALC663_ASUS_MODE4] = "asus-mode4",
17714         [ALC663_ASUS_MODE5] = "asus-mode5",
17715         [ALC663_ASUS_MODE6] = "asus-mode6",
17716         [ALC663_ASUS_MODE7] = "asus-mode7",
17717         [ALC663_ASUS_MODE8] = "asus-mode8",
17718         [ALC272_DELL]           = "dell",
17719         [ALC272_DELL_ZM1]       = "dell-zm1",
17720         [ALC272_SAMSUNG_NC10]   = "samsung-nc10",
17721         [ALC662_AUTO]           = "auto",
17722 };
17723
17724 static struct snd_pci_quirk alc662_cfg_tbl[] = {
17725         SND_PCI_QUIRK(0x1019, 0x9087, "ECS", ALC662_ECS),
17726         SND_PCI_QUIRK(0x1028, 0x02d6, "DELL", ALC272_DELL),
17727         SND_PCI_QUIRK(0x1028, 0x02f4, "DELL ZM1", ALC272_DELL_ZM1),
17728         SND_PCI_QUIRK(0x1043, 0x1000, "ASUS N50Vm", ALC663_ASUS_MODE1),
17729         SND_PCI_QUIRK(0x1043, 0x1092, "ASUS NB", ALC663_ASUS_MODE3),
17730         SND_PCI_QUIRK(0x1043, 0x1173, "ASUS K73Jn", ALC663_ASUS_MODE1),
17731         SND_PCI_QUIRK(0x1043, 0x11c3, "ASUS M70V", ALC663_ASUS_MODE3),
17732         SND_PCI_QUIRK(0x1043, 0x11d3, "ASUS NB", ALC663_ASUS_MODE1),
17733         SND_PCI_QUIRK(0x1043, 0x11f3, "ASUS NB", ALC662_ASUS_MODE2),
17734         SND_PCI_QUIRK(0x1043, 0x1203, "ASUS NB", ALC663_ASUS_MODE1),
17735         SND_PCI_QUIRK(0x1043, 0x1303, "ASUS G60J", ALC663_ASUS_MODE1),
17736         SND_PCI_QUIRK(0x1043, 0x1333, "ASUS G60Jx", ALC663_ASUS_MODE1),
17737         SND_PCI_QUIRK(0x1043, 0x1339, "ASUS NB", ALC662_ASUS_MODE2),
17738         SND_PCI_QUIRK(0x1043, 0x13e3, "ASUS N71JA", ALC663_ASUS_MODE7),
17739         SND_PCI_QUIRK(0x1043, 0x1463, "ASUS N71", ALC663_ASUS_MODE7),
17740         SND_PCI_QUIRK(0x1043, 0x14d3, "ASUS G72", ALC663_ASUS_MODE8),
17741         SND_PCI_QUIRK(0x1043, 0x1563, "ASUS N90", ALC663_ASUS_MODE3),
17742         SND_PCI_QUIRK(0x1043, 0x15d3, "ASUS N50SF F50SF", ALC663_ASUS_MODE1),
17743         SND_PCI_QUIRK(0x1043, 0x16c3, "ASUS NB", ALC662_ASUS_MODE2),
17744         SND_PCI_QUIRK(0x1043, 0x16f3, "ASUS K40C K50C", ALC662_ASUS_MODE2),
17745         SND_PCI_QUIRK(0x1043, 0x1733, "ASUS N81De", ALC663_ASUS_MODE1),
17746         SND_PCI_QUIRK(0x1043, 0x1753, "ASUS NB", ALC662_ASUS_MODE2),
17747         SND_PCI_QUIRK(0x1043, 0x1763, "ASUS NB", ALC663_ASUS_MODE6),
17748         SND_PCI_QUIRK(0x1043, 0x1765, "ASUS NB", ALC663_ASUS_MODE6),
17749         SND_PCI_QUIRK(0x1043, 0x1783, "ASUS NB", ALC662_ASUS_MODE2),
17750         SND_PCI_QUIRK(0x1043, 0x1793, "ASUS F50GX", ALC663_ASUS_MODE1),
17751         SND_PCI_QUIRK(0x1043, 0x17b3, "ASUS F70SL", ALC663_ASUS_MODE3),
17752         SND_PCI_QUIRK(0x1043, 0x17c3, "ASUS UX20", ALC663_ASUS_M51VA),
17753         SND_PCI_QUIRK(0x1043, 0x17f3, "ASUS X58LE", ALC662_ASUS_MODE2),
17754         SND_PCI_QUIRK(0x1043, 0x1813, "ASUS NB", ALC662_ASUS_MODE2),
17755         SND_PCI_QUIRK(0x1043, 0x1823, "ASUS NB", ALC663_ASUS_MODE5),
17756         SND_PCI_QUIRK(0x1043, 0x1833, "ASUS NB", ALC663_ASUS_MODE6),
17757         SND_PCI_QUIRK(0x1043, 0x1843, "ASUS NB", ALC662_ASUS_MODE2),
17758         SND_PCI_QUIRK(0x1043, 0x1853, "ASUS F50Z", ALC663_ASUS_MODE1),
17759         SND_PCI_QUIRK(0x1043, 0x1864, "ASUS NB", ALC662_ASUS_MODE2),
17760         SND_PCI_QUIRK(0x1043, 0x1876, "ASUS NB", ALC662_ASUS_MODE2),
17761         SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M51VA", ALC663_ASUS_M51VA),
17762         /*SND_PCI_QUIRK(0x1043, 0x1878, "ASUS M50Vr", ALC663_ASUS_MODE1),*/
17763         SND_PCI_QUIRK(0x1043, 0x1893, "ASUS M50Vm", ALC663_ASUS_MODE3),
17764         SND_PCI_QUIRK(0x1043, 0x1894, "ASUS X55", ALC663_ASUS_MODE3),
17765         SND_PCI_QUIRK(0x1043, 0x18b3, "ASUS N80Vc", ALC663_ASUS_MODE1),
17766         SND_PCI_QUIRK(0x1043, 0x18c3, "ASUS VX5", ALC663_ASUS_MODE1),
17767         SND_PCI_QUIRK(0x1043, 0x18d3, "ASUS N81Te", ALC663_ASUS_MODE1),
17768         SND_PCI_QUIRK(0x1043, 0x18f3, "ASUS N505Tp", ALC663_ASUS_MODE1),
17769         SND_PCI_QUIRK(0x1043, 0x1903, "ASUS F5GL", ALC663_ASUS_MODE1),
17770         SND_PCI_QUIRK(0x1043, 0x1913, "ASUS NB", ALC662_ASUS_MODE2),
17771         SND_PCI_QUIRK(0x1043, 0x1933, "ASUS F80Q", ALC662_ASUS_MODE2),
17772         SND_PCI_QUIRK(0x1043, 0x1943, "ASUS Vx3V", ALC663_ASUS_MODE1),
17773         SND_PCI_QUIRK(0x1043, 0x1953, "ASUS NB", ALC663_ASUS_MODE1),
17774         SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71C", ALC663_ASUS_MODE3),
17775         SND_PCI_QUIRK(0x1043, 0x1983, "ASUS N5051A", ALC663_ASUS_MODE1),
17776         SND_PCI_QUIRK(0x1043, 0x1993, "ASUS N20", ALC663_ASUS_MODE1),
17777         SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS G50V", ALC663_ASUS_G50V),
17778         /*SND_PCI_QUIRK(0x1043, 0x19a3, "ASUS NB", ALC663_ASUS_MODE1),*/
17779         SND_PCI_QUIRK(0x1043, 0x19b3, "ASUS F7Z", ALC663_ASUS_MODE1),
17780         SND_PCI_QUIRK(0x1043, 0x19c3, "ASUS F5Z/F6x", ALC662_ASUS_MODE2),
17781         SND_PCI_QUIRK(0x1043, 0x19d3, "ASUS NB", ALC663_ASUS_M51VA),
17782         SND_PCI_QUIRK(0x1043, 0x19e3, "ASUS NB", ALC663_ASUS_MODE1),
17783         SND_PCI_QUIRK(0x1043, 0x19f3, "ASUS NB", ALC663_ASUS_MODE4),
17784         SND_PCI_QUIRK(0x1043, 0x8290, "ASUS P5GC-MX", ALC662_3ST_6ch_DIG),
17785         SND_PCI_QUIRK(0x1043, 0x82a1, "ASUS Eeepc", ALC662_ASUS_EEEPC_P701),
17786         SND_PCI_QUIRK(0x1043, 0x82d1, "ASUS Eeepc EP20", ALC662_ASUS_EEEPC_EP20),
17787         SND_PCI_QUIRK(0x105b, 0x0cd6, "Foxconn", ALC662_ECS),
17788         SND_PCI_QUIRK(0x105b, 0x0d47, "Foxconn 45CMX/45GMX/45CMX-K",
17789                       ALC662_3ST_6ch_DIG),
17790         SND_PCI_QUIRK(0x1179, 0xff6e, "Toshiba NB20x", ALC662_AUTO),
17791         SND_PCI_QUIRK(0x144d, 0xca00, "Samsung NC10", ALC272_SAMSUNG_NC10),
17792         SND_PCI_QUIRK(0x1458, 0xa002, "Gigabyte 945GCM-S2L",
17793                       ALC662_3ST_6ch_DIG),
17794         SND_PCI_QUIRK(0x152d, 0x2304, "Quanta WH1", ALC663_ASUS_H13),
17795         SND_PCI_QUIRK(0x1565, 0x820f, "Biostar TA780G M2+", ALC662_3ST_6ch_DIG),
17796         SND_PCI_QUIRK(0x1631, 0xc10c, "PB RS65", ALC663_ASUS_M51VA),
17797         SND_PCI_QUIRK(0x17aa, 0x101e, "Lenovo", ALC662_LENOVO_101E),
17798         SND_PCI_QUIRK(0x1849, 0x3662, "ASROCK K10N78FullHD-hSLI R3.0",
17799                                         ALC662_3ST_6ch_DIG),
17800         SND_PCI_QUIRK_MASK(0x1854, 0xf000, 0x2000, "ASUS H13-200x",
17801                            ALC663_ASUS_H13),
17802         SND_PCI_QUIRK(0x8086, 0xd604, "Intel mobo", ALC662_3ST_2ch_DIG),
17803         {}
17804 };
17805
17806 static struct alc_config_preset alc662_presets[] = {
17807         [ALC662_3ST_2ch_DIG] = {
17808                 .mixers = { alc662_3ST_2ch_mixer },
17809                 .init_verbs = { alc662_init_verbs },
17810                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17811                 .dac_nids = alc662_dac_nids,
17812                 .dig_out_nid = ALC662_DIGOUT_NID,
17813                 .dig_in_nid = ALC662_DIGIN_NID,
17814                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17815                 .channel_mode = alc662_3ST_2ch_modes,
17816                 .input_mux = &alc662_capture_source,
17817         },
17818         [ALC662_3ST_6ch_DIG] = {
17819                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17820                 .init_verbs = { alc662_init_verbs },
17821                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17822                 .dac_nids = alc662_dac_nids,
17823                 .dig_out_nid = ALC662_DIGOUT_NID,
17824                 .dig_in_nid = ALC662_DIGIN_NID,
17825                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17826                 .channel_mode = alc662_3ST_6ch_modes,
17827                 .need_dac_fix = 1,
17828                 .input_mux = &alc662_capture_source,
17829         },
17830         [ALC662_3ST_6ch] = {
17831                 .mixers = { alc662_3ST_6ch_mixer, alc662_chmode_mixer },
17832                 .init_verbs = { alc662_init_verbs },
17833                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17834                 .dac_nids = alc662_dac_nids,
17835                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17836                 .channel_mode = alc662_3ST_6ch_modes,
17837                 .need_dac_fix = 1,
17838                 .input_mux = &alc662_capture_source,
17839         },
17840         [ALC662_5ST_DIG] = {
17841                 .mixers = { alc662_base_mixer, alc662_chmode_mixer },
17842                 .init_verbs = { alc662_init_verbs },
17843                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17844                 .dac_nids = alc662_dac_nids,
17845                 .dig_out_nid = ALC662_DIGOUT_NID,
17846                 .dig_in_nid = ALC662_DIGIN_NID,
17847                 .num_channel_mode = ARRAY_SIZE(alc662_5stack_modes),
17848                 .channel_mode = alc662_5stack_modes,
17849                 .input_mux = &alc662_capture_source,
17850         },
17851         [ALC662_LENOVO_101E] = {
17852                 .mixers = { alc662_lenovo_101e_mixer },
17853                 .init_verbs = { alc662_init_verbs, alc662_sue_init_verbs },
17854                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17855                 .dac_nids = alc662_dac_nids,
17856                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17857                 .channel_mode = alc662_3ST_2ch_modes,
17858                 .input_mux = &alc662_lenovo_101e_capture_source,
17859                 .unsol_event = alc662_lenovo_101e_unsol_event,
17860                 .init_hook = alc662_lenovo_101e_all_automute,
17861         },
17862         [ALC662_ASUS_EEEPC_P701] = {
17863                 .mixers = { alc662_eeepc_p701_mixer },
17864                 .init_verbs = { alc662_init_verbs,
17865                                 alc662_eeepc_sue_init_verbs },
17866                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17867                 .dac_nids = alc662_dac_nids,
17868                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17869                 .channel_mode = alc662_3ST_2ch_modes,
17870                 .unsol_event = alc662_eeepc_unsol_event,
17871                 .setup = alc662_eeepc_setup,
17872                 .init_hook = alc662_eeepc_inithook,
17873         },
17874         [ALC662_ASUS_EEEPC_EP20] = {
17875                 .mixers = { alc662_eeepc_ep20_mixer,
17876                             alc662_chmode_mixer },
17877                 .init_verbs = { alc662_init_verbs,
17878                                 alc662_eeepc_ep20_sue_init_verbs },
17879                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17880                 .dac_nids = alc662_dac_nids,
17881                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17882                 .channel_mode = alc662_3ST_6ch_modes,
17883                 .input_mux = &alc662_lenovo_101e_capture_source,
17884                 .unsol_event = alc662_eeepc_unsol_event,
17885                 .setup = alc662_eeepc_ep20_setup,
17886                 .init_hook = alc662_eeepc_ep20_inithook,
17887         },
17888         [ALC662_ECS] = {
17889                 .mixers = { alc662_ecs_mixer },
17890                 .init_verbs = { alc662_init_verbs,
17891                                 alc662_ecs_init_verbs },
17892                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17893                 .dac_nids = alc662_dac_nids,
17894                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17895                 .channel_mode = alc662_3ST_2ch_modes,
17896                 .unsol_event = alc662_eeepc_unsol_event,
17897                 .setup = alc662_eeepc_setup,
17898                 .init_hook = alc662_eeepc_inithook,
17899         },
17900         [ALC663_ASUS_M51VA] = {
17901                 .mixers = { alc663_m51va_mixer },
17902                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17903                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17904                 .dac_nids = alc662_dac_nids,
17905                 .dig_out_nid = ALC662_DIGOUT_NID,
17906                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17907                 .channel_mode = alc662_3ST_2ch_modes,
17908                 .unsol_event = alc663_m51va_unsol_event,
17909                 .setup = alc663_m51va_setup,
17910                 .init_hook = alc663_m51va_inithook,
17911         },
17912         [ALC663_ASUS_G71V] = {
17913                 .mixers = { alc663_g71v_mixer },
17914                 .init_verbs = { alc662_init_verbs, alc663_g71v_init_verbs },
17915                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17916                 .dac_nids = alc662_dac_nids,
17917                 .dig_out_nid = ALC662_DIGOUT_NID,
17918                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17919                 .channel_mode = alc662_3ST_2ch_modes,
17920                 .unsol_event = alc663_g71v_unsol_event,
17921                 .setup = alc663_g71v_setup,
17922                 .init_hook = alc663_g71v_inithook,
17923         },
17924         [ALC663_ASUS_H13] = {
17925                 .mixers = { alc663_m51va_mixer },
17926                 .init_verbs = { alc662_init_verbs, alc663_m51va_init_verbs },
17927                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17928                 .dac_nids = alc662_dac_nids,
17929                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17930                 .channel_mode = alc662_3ST_2ch_modes,
17931                 .unsol_event = alc663_m51va_unsol_event,
17932                 .init_hook = alc663_m51va_inithook,
17933         },
17934         [ALC663_ASUS_G50V] = {
17935                 .mixers = { alc663_g50v_mixer },
17936                 .init_verbs = { alc662_init_verbs, alc663_g50v_init_verbs },
17937                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17938                 .dac_nids = alc662_dac_nids,
17939                 .dig_out_nid = ALC662_DIGOUT_NID,
17940                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_6ch_modes),
17941                 .channel_mode = alc662_3ST_6ch_modes,
17942                 .input_mux = &alc663_capture_source,
17943                 .unsol_event = alc663_g50v_unsol_event,
17944                 .setup = alc663_g50v_setup,
17945                 .init_hook = alc663_g50v_inithook,
17946         },
17947         [ALC663_ASUS_MODE1] = {
17948                 .mixers = { alc663_m51va_mixer },
17949                 .cap_mixer = alc662_auto_capture_mixer,
17950                 .init_verbs = { alc662_init_verbs,
17951                                 alc663_21jd_amic_init_verbs },
17952                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17953                 .hp_nid = 0x03,
17954                 .dac_nids = alc662_dac_nids,
17955                 .dig_out_nid = ALC662_DIGOUT_NID,
17956                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17957                 .channel_mode = alc662_3ST_2ch_modes,
17958                 .unsol_event = alc663_mode1_unsol_event,
17959                 .setup = alc663_mode1_setup,
17960                 .init_hook = alc663_mode1_inithook,
17961         },
17962         [ALC662_ASUS_MODE2] = {
17963                 .mixers = { alc662_1bjd_mixer },
17964                 .cap_mixer = alc662_auto_capture_mixer,
17965                 .init_verbs = { alc662_init_verbs,
17966                                 alc662_1bjd_amic_init_verbs },
17967                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17968                 .dac_nids = alc662_dac_nids,
17969                 .dig_out_nid = ALC662_DIGOUT_NID,
17970                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17971                 .channel_mode = alc662_3ST_2ch_modes,
17972                 .unsol_event = alc662_mode2_unsol_event,
17973                 .setup = alc662_mode2_setup,
17974                 .init_hook = alc662_mode2_inithook,
17975         },
17976         [ALC663_ASUS_MODE3] = {
17977                 .mixers = { alc663_two_hp_m1_mixer },
17978                 .cap_mixer = alc662_auto_capture_mixer,
17979                 .init_verbs = { alc662_init_verbs,
17980                                 alc663_two_hp_amic_m1_init_verbs },
17981                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17982                 .hp_nid = 0x03,
17983                 .dac_nids = alc662_dac_nids,
17984                 .dig_out_nid = ALC662_DIGOUT_NID,
17985                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
17986                 .channel_mode = alc662_3ST_2ch_modes,
17987                 .unsol_event = alc663_mode3_unsol_event,
17988                 .setup = alc663_mode3_setup,
17989                 .init_hook = alc663_mode3_inithook,
17990         },
17991         [ALC663_ASUS_MODE4] = {
17992                 .mixers = { alc663_asus_21jd_clfe_mixer },
17993                 .cap_mixer = alc662_auto_capture_mixer,
17994                 .init_verbs = { alc662_init_verbs,
17995                                 alc663_21jd_amic_init_verbs},
17996                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
17997                 .hp_nid = 0x03,
17998                 .dac_nids = alc662_dac_nids,
17999                 .dig_out_nid = ALC662_DIGOUT_NID,
18000                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18001                 .channel_mode = alc662_3ST_2ch_modes,
18002                 .unsol_event = alc663_mode4_unsol_event,
18003                 .setup = alc663_mode4_setup,
18004                 .init_hook = alc663_mode4_inithook,
18005         },
18006         [ALC663_ASUS_MODE5] = {
18007                 .mixers = { alc663_asus_15jd_clfe_mixer },
18008                 .cap_mixer = alc662_auto_capture_mixer,
18009                 .init_verbs = { alc662_init_verbs,
18010                                 alc663_15jd_amic_init_verbs },
18011                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18012                 .hp_nid = 0x03,
18013                 .dac_nids = alc662_dac_nids,
18014                 .dig_out_nid = ALC662_DIGOUT_NID,
18015                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18016                 .channel_mode = alc662_3ST_2ch_modes,
18017                 .unsol_event = alc663_mode5_unsol_event,
18018                 .setup = alc663_mode5_setup,
18019                 .init_hook = alc663_mode5_inithook,
18020         },
18021         [ALC663_ASUS_MODE6] = {
18022                 .mixers = { alc663_two_hp_m2_mixer },
18023                 .cap_mixer = alc662_auto_capture_mixer,
18024                 .init_verbs = { alc662_init_verbs,
18025                                 alc663_two_hp_amic_m2_init_verbs },
18026                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18027                 .hp_nid = 0x03,
18028                 .dac_nids = alc662_dac_nids,
18029                 .dig_out_nid = ALC662_DIGOUT_NID,
18030                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18031                 .channel_mode = alc662_3ST_2ch_modes,
18032                 .unsol_event = alc663_mode6_unsol_event,
18033                 .setup = alc663_mode6_setup,
18034                 .init_hook = alc663_mode6_inithook,
18035         },
18036         [ALC663_ASUS_MODE7] = {
18037                 .mixers = { alc663_mode7_mixer },
18038                 .cap_mixer = alc662_auto_capture_mixer,
18039                 .init_verbs = { alc662_init_verbs,
18040                                 alc663_mode7_init_verbs },
18041                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18042                 .hp_nid = 0x03,
18043                 .dac_nids = alc662_dac_nids,
18044                 .dig_out_nid = ALC662_DIGOUT_NID,
18045                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18046                 .channel_mode = alc662_3ST_2ch_modes,
18047                 .unsol_event = alc663_mode7_unsol_event,
18048                 .setup = alc663_mode7_setup,
18049                 .init_hook = alc663_mode7_inithook,
18050         },
18051         [ALC663_ASUS_MODE8] = {
18052                 .mixers = { alc663_mode8_mixer },
18053                 .cap_mixer = alc662_auto_capture_mixer,
18054                 .init_verbs = { alc662_init_verbs,
18055                                 alc663_mode8_init_verbs },
18056                 .num_dacs = ARRAY_SIZE(alc662_dac_nids),
18057                 .hp_nid = 0x03,
18058                 .dac_nids = alc662_dac_nids,
18059                 .dig_out_nid = ALC662_DIGOUT_NID,
18060                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18061                 .channel_mode = alc662_3ST_2ch_modes,
18062                 .unsol_event = alc663_mode8_unsol_event,
18063                 .setup = alc663_mode8_setup,
18064                 .init_hook = alc663_mode8_inithook,
18065         },
18066         [ALC272_DELL] = {
18067                 .mixers = { alc663_m51va_mixer },
18068                 .cap_mixer = alc272_auto_capture_mixer,
18069                 .init_verbs = { alc662_init_verbs, alc272_dell_init_verbs },
18070                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18071                 .dac_nids = alc662_dac_nids,
18072                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18073                 .adc_nids = alc272_adc_nids,
18074                 .num_adc_nids = ARRAY_SIZE(alc272_adc_nids),
18075                 .capsrc_nids = alc272_capsrc_nids,
18076                 .channel_mode = alc662_3ST_2ch_modes,
18077                 .unsol_event = alc663_m51va_unsol_event,
18078                 .setup = alc663_m51va_setup,
18079                 .init_hook = alc663_m51va_inithook,
18080         },
18081         [ALC272_DELL_ZM1] = {
18082                 .mixers = { alc663_m51va_mixer },
18083                 .cap_mixer = alc662_auto_capture_mixer,
18084                 .init_verbs = { alc662_init_verbs, alc272_dell_zm1_init_verbs },
18085                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18086                 .dac_nids = alc662_dac_nids,
18087                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18088                 .adc_nids = alc662_adc_nids,
18089                 .num_adc_nids = 1,
18090                 .capsrc_nids = alc662_capsrc_nids,
18091                 .channel_mode = alc662_3ST_2ch_modes,
18092                 .unsol_event = alc663_m51va_unsol_event,
18093                 .setup = alc663_m51va_setup,
18094                 .init_hook = alc663_m51va_inithook,
18095         },
18096         [ALC272_SAMSUNG_NC10] = {
18097                 .mixers = { alc272_nc10_mixer },
18098                 .init_verbs = { alc662_init_verbs,
18099                                 alc663_21jd_amic_init_verbs },
18100                 .num_dacs = ARRAY_SIZE(alc272_dac_nids),
18101                 .dac_nids = alc272_dac_nids,
18102                 .num_channel_mode = ARRAY_SIZE(alc662_3ST_2ch_modes),
18103                 .channel_mode = alc662_3ST_2ch_modes,
18104                 /*.input_mux = &alc272_nc10_capture_source,*/
18105                 .unsol_event = alc663_mode4_unsol_event,
18106                 .setup = alc663_mode4_setup,
18107                 .init_hook = alc663_mode4_inithook,
18108         },
18109 };
18110
18111
18112 /*
18113  * BIOS auto configuration
18114  */
18115
18116 /* convert from MIX nid to DAC */
18117 static inline hda_nid_t alc662_mix_to_dac(hda_nid_t nid)
18118 {
18119         if (nid == 0x0f)
18120                 return 0x02;
18121         else if (nid >= 0x0c && nid <= 0x0e)
18122                 return nid - 0x0c + 0x02;
18123         else
18124                 return 0;
18125 }
18126
18127 /* get MIX nid connected to the given pin targeted to DAC */
18128 static hda_nid_t alc662_dac_to_mix(struct hda_codec *codec, hda_nid_t pin,
18129                                    hda_nid_t dac)
18130 {
18131         hda_nid_t mix[4];
18132         int i, num;
18133
18134         num = snd_hda_get_connections(codec, pin, mix, ARRAY_SIZE(mix));
18135         for (i = 0; i < num; i++) {
18136                 if (alc662_mix_to_dac(mix[i]) == dac)
18137                         return mix[i];
18138         }
18139         return 0;
18140 }
18141
18142 /* look for an empty DAC slot */
18143 static hda_nid_t alc662_look_for_dac(struct hda_codec *codec, hda_nid_t pin)
18144 {
18145         struct alc_spec *spec = codec->spec;
18146         hda_nid_t srcs[5];
18147         int i, j, num;
18148
18149         num = snd_hda_get_connections(codec, pin, srcs, ARRAY_SIZE(srcs));
18150         if (num < 0)
18151                 return 0;
18152         for (i = 0; i < num; i++) {
18153                 hda_nid_t nid = alc662_mix_to_dac(srcs[i]);
18154                 if (!nid)
18155                         continue;
18156                 for (j = 0; j < spec->multiout.num_dacs; j++)
18157                         if (spec->multiout.dac_nids[j] == nid)
18158                                 break;
18159                 if (j >= spec->multiout.num_dacs)
18160                         return nid;
18161         }
18162         return 0;
18163 }
18164
18165 /* fill in the dac_nids table from the parsed pin configuration */
18166 static int alc662_auto_fill_dac_nids(struct hda_codec *codec,
18167                                      const struct auto_pin_cfg *cfg)
18168 {
18169         struct alc_spec *spec = codec->spec;
18170         int i;
18171         hda_nid_t dac;
18172
18173         spec->multiout.dac_nids = spec->private_dac_nids;
18174         for (i = 0; i < cfg->line_outs; i++) {
18175                 dac = alc662_look_for_dac(codec, cfg->line_out_pins[i]);
18176                 if (!dac)
18177                         continue;
18178                 spec->multiout.dac_nids[spec->multiout.num_dacs++] = dac;
18179         }
18180         return 0;
18181 }
18182
18183 static inline int alc662_add_vol_ctl(struct alc_spec *spec, const char *pfx,
18184                               hda_nid_t nid, unsigned int chs)
18185 {
18186         return add_pb_vol_ctrl(spec, ALC_CTL_WIDGET_VOL, pfx,
18187                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_OUTPUT));
18188 }
18189
18190 static inline int alc662_add_sw_ctl(struct alc_spec *spec, const char *pfx,
18191                              hda_nid_t nid, unsigned int chs)
18192 {
18193         return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18194                            HDA_COMPOSE_AMP_VAL(nid, chs, 0, HDA_INPUT));
18195 }
18196
18197 #define alc662_add_stereo_vol(spec, pfx, nid) \
18198         alc662_add_vol_ctl(spec, pfx, nid, 3)
18199 #define alc662_add_stereo_sw(spec, pfx, nid) \
18200         alc662_add_sw_ctl(spec, pfx, nid, 3)
18201
18202 /* add playback controls from the parsed DAC table */
18203 static int alc662_auto_create_multi_out_ctls(struct hda_codec *codec,
18204                                              const struct auto_pin_cfg *cfg)
18205 {
18206         struct alc_spec *spec = codec->spec;
18207         static const char *chname[4] = {
18208                 "Front", "Surround", NULL /*CLFE*/, "Side"
18209         };
18210         hda_nid_t nid, mix;
18211         int i, err;
18212
18213         for (i = 0; i < cfg->line_outs; i++) {
18214                 nid = spec->multiout.dac_nids[i];
18215                 if (!nid)
18216                         continue;
18217                 mix = alc662_dac_to_mix(codec, cfg->line_out_pins[i], nid);
18218                 if (!mix)
18219                         continue;
18220                 if (i == 2) {
18221                         /* Center/LFE */
18222                         err = alc662_add_vol_ctl(spec, "Center", nid, 1);
18223                         if (err < 0)
18224                                 return err;
18225                         err = alc662_add_vol_ctl(spec, "LFE", nid, 2);
18226                         if (err < 0)
18227                                 return err;
18228                         err = alc662_add_sw_ctl(spec, "Center", mix, 1);
18229                         if (err < 0)
18230                                 return err;
18231                         err = alc662_add_sw_ctl(spec, "LFE", mix, 2);
18232                         if (err < 0)
18233                                 return err;
18234                 } else {
18235                         const char *pfx;
18236                         if (cfg->line_outs == 1 &&
18237                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
18238                                 if (cfg->hp_outs)
18239                                         pfx = "Speaker";
18240                                 else
18241                                         pfx = "PCM";
18242                         } else
18243                                 pfx = chname[i];
18244                         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18245                         if (err < 0)
18246                                 return err;
18247                         if (cfg->line_outs == 1 &&
18248                             cfg->line_out_type == AUTO_PIN_SPEAKER_OUT)
18249                                 pfx = "Speaker";
18250                         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18251                         if (err < 0)
18252                                 return err;
18253                 }
18254         }
18255         return 0;
18256 }
18257
18258 /* add playback controls for speaker and HP outputs */
18259 /* return DAC nid if any new DAC is assigned */
18260 static int alc662_auto_create_extra_out(struct hda_codec *codec, hda_nid_t pin,
18261                                         const char *pfx)
18262 {
18263         struct alc_spec *spec = codec->spec;
18264         hda_nid_t nid, mix;
18265         int err;
18266
18267         if (!pin)
18268                 return 0;
18269         nid = alc662_look_for_dac(codec, pin);
18270         if (!nid) {
18271                 /* the corresponding DAC is already occupied */
18272                 if (!(get_wcaps(codec, pin) & AC_WCAP_OUT_AMP))
18273                         return 0; /* no way */
18274                 /* create a switch only */
18275                 return add_pb_sw_ctrl(spec, ALC_CTL_WIDGET_MUTE, pfx,
18276                                    HDA_COMPOSE_AMP_VAL(pin, 3, 0, HDA_OUTPUT));
18277         }
18278
18279         mix = alc662_dac_to_mix(codec, pin, nid);
18280         if (!mix)
18281                 return 0;
18282         err = alc662_add_vol_ctl(spec, pfx, nid, 3);
18283         if (err < 0)
18284                 return err;
18285         err = alc662_add_sw_ctl(spec, pfx, mix, 3);
18286         if (err < 0)
18287                 return err;
18288         return nid;
18289 }
18290
18291 /* create playback/capture controls for input pins */
18292 #define alc662_auto_create_input_ctls \
18293         alc882_auto_create_input_ctls
18294
18295 static void alc662_auto_set_output_and_unmute(struct hda_codec *codec,
18296                                               hda_nid_t nid, int pin_type,
18297                                               hda_nid_t dac)
18298 {
18299         int i, num;
18300         hda_nid_t srcs[4];
18301
18302         alc_set_pin_output(codec, nid, pin_type);
18303         /* need the manual connection? */
18304         num = snd_hda_get_connections(codec, nid, srcs, ARRAY_SIZE(srcs));
18305         if (num <= 1)
18306                 return;
18307         for (i = 0; i < num; i++) {
18308                 if (alc662_mix_to_dac(srcs[i]) != dac)
18309                         continue;
18310                 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CONNECT_SEL, i);
18311                 return;
18312         }
18313 }
18314
18315 static void alc662_auto_init_multi_out(struct hda_codec *codec)
18316 {
18317         struct alc_spec *spec = codec->spec;
18318         int pin_type = get_pin_type(spec->autocfg.line_out_type);
18319         int i;
18320
18321         for (i = 0; i <= HDA_SIDE; i++) {
18322                 hda_nid_t nid = spec->autocfg.line_out_pins[i];
18323                 if (nid)
18324                         alc662_auto_set_output_and_unmute(codec, nid, pin_type,
18325                                         spec->multiout.dac_nids[i]);
18326         }
18327 }
18328
18329 static void alc662_auto_init_hp_out(struct hda_codec *codec)
18330 {
18331         struct alc_spec *spec = codec->spec;
18332         hda_nid_t pin;
18333
18334         pin = spec->autocfg.hp_pins[0];
18335         if (pin)
18336                 alc662_auto_set_output_and_unmute(codec, pin, PIN_HP,
18337                                                   spec->multiout.hp_nid);
18338         pin = spec->autocfg.speaker_pins[0];
18339         if (pin)
18340                 alc662_auto_set_output_and_unmute(codec, pin, PIN_OUT,
18341                                         spec->multiout.extra_out_nid[0]);
18342 }
18343
18344 #define ALC662_PIN_CD_NID               ALC880_PIN_CD_NID
18345
18346 static void alc662_auto_init_analog_input(struct hda_codec *codec)
18347 {
18348         struct alc_spec *spec = codec->spec;
18349         int i;
18350
18351         for (i = 0; i < AUTO_PIN_LAST; i++) {
18352                 hda_nid_t nid = spec->autocfg.input_pins[i];
18353                 if (alc_is_input_pin(codec, nid)) {
18354                         alc_set_input_pin(codec, nid, i);
18355                         if (nid != ALC662_PIN_CD_NID &&
18356                             (get_wcaps(codec, nid) & AC_WCAP_OUT_AMP))
18357                                 snd_hda_codec_write(codec, nid, 0,
18358                                                     AC_VERB_SET_AMP_GAIN_MUTE,
18359                                                     AMP_OUT_MUTE);
18360                 }
18361         }
18362 }
18363
18364 #define alc662_auto_init_input_src      alc882_auto_init_input_src
18365
18366 static int alc662_parse_auto_config(struct hda_codec *codec)
18367 {
18368         struct alc_spec *spec = codec->spec;
18369         int err;
18370         static hda_nid_t alc662_ignore[] = { 0x1d, 0 };
18371
18372         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg,
18373                                            alc662_ignore);
18374         if (err < 0)
18375                 return err;
18376         if (!spec->autocfg.line_outs)
18377                 return 0; /* can't find valid BIOS pin config */
18378
18379         err = alc662_auto_fill_dac_nids(codec, &spec->autocfg);
18380         if (err < 0)
18381                 return err;
18382         err = alc662_auto_create_multi_out_ctls(codec, &spec->autocfg);
18383         if (err < 0)
18384                 return err;
18385         err = alc662_auto_create_extra_out(codec,
18386                                            spec->autocfg.speaker_pins[0],
18387                                            "Speaker");
18388         if (err < 0)
18389                 return err;
18390         if (err)
18391                 spec->multiout.extra_out_nid[0] = err;
18392         err = alc662_auto_create_extra_out(codec, spec->autocfg.hp_pins[0],
18393                                            "Headphone");
18394         if (err < 0)
18395                 return err;
18396         if (err)
18397                 spec->multiout.hp_nid = err;
18398         err = alc662_auto_create_input_ctls(codec, &spec->autocfg);
18399         if (err < 0)
18400                 return err;
18401
18402         spec->multiout.max_channels = spec->multiout.num_dacs * 2;
18403
18404         if (spec->autocfg.dig_outs)
18405                 spec->multiout.dig_out_nid = ALC880_DIGOUT_NID;
18406
18407         if (spec->kctls.list)
18408                 add_mixer(spec, spec->kctls.list);
18409
18410         spec->num_mux_defs = 1;
18411         spec->input_mux = &spec->private_imux[0];
18412
18413         add_verb(spec, alc662_init_verbs);
18414         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18415             codec->vendor_id == 0x10ec0665)
18416                 add_verb(spec, alc663_init_verbs);
18417
18418         if (codec->vendor_id == 0x10ec0272)
18419                 add_verb(spec, alc272_init_verbs);
18420
18421         err = alc_auto_add_mic_boost(codec);
18422         if (err < 0)
18423                 return err;
18424
18425         if (codec->vendor_id == 0x10ec0272 || codec->vendor_id == 0x10ec0663 ||
18426             codec->vendor_id == 0x10ec0665 || codec->vendor_id == 0x10ec0670)
18427             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0x21);
18428         else
18429             alc_ssid_check(codec, 0x15, 0x1b, 0x14, 0);
18430
18431         return 1;
18432 }
18433
18434 /* additional initialization for auto-configuration model */
18435 static void alc662_auto_init(struct hda_codec *codec)
18436 {
18437         struct alc_spec *spec = codec->spec;
18438         alc662_auto_init_multi_out(codec);
18439         alc662_auto_init_hp_out(codec);
18440         alc662_auto_init_analog_input(codec);
18441         alc662_auto_init_input_src(codec);
18442         if (spec->unsol_event)
18443                 alc_inithook(codec);
18444 }
18445
18446 static int patch_alc662(struct hda_codec *codec)
18447 {
18448         struct alc_spec *spec;
18449         int err, board_config;
18450
18451         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
18452         if (!spec)
18453                 return -ENOMEM;
18454
18455         codec->spec = spec;
18456
18457         alc_fix_pll_init(codec, 0x20, 0x04, 15);
18458
18459         if (alc_read_coef_idx(codec, 0)==0x8020){
18460                 kfree(codec->chip_name);
18461                 codec->chip_name = kstrdup("ALC661", GFP_KERNEL);
18462                 if (!codec->chip_name) {
18463                         alc_free(codec);
18464                         return -ENOMEM;
18465                 }
18466         }
18467
18468         board_config = snd_hda_check_board_config(codec, ALC662_MODEL_LAST,
18469                                                   alc662_models,
18470                                                   alc662_cfg_tbl);
18471         if (board_config < 0) {
18472                 printk(KERN_INFO "hda_codec: %s: BIOS auto-probing.\n",
18473                        codec->chip_name);
18474                 board_config = ALC662_AUTO;
18475         }
18476
18477         if (board_config == ALC662_AUTO) {
18478                 /* automatic parse from the BIOS config */
18479                 err = alc662_parse_auto_config(codec);
18480                 if (err < 0) {
18481                         alc_free(codec);
18482                         return err;
18483                 } else if (!err) {
18484                         printk(KERN_INFO
18485                                "hda_codec: Cannot set up configuration "
18486                                "from BIOS.  Using base mode...\n");
18487                         board_config = ALC662_3ST_2ch_DIG;
18488                 }
18489         }
18490
18491         err = snd_hda_attach_beep_device(codec, 0x1);
18492         if (err < 0) {
18493                 alc_free(codec);
18494                 return err;
18495         }
18496
18497         if (board_config != ALC662_AUTO)
18498                 setup_preset(codec, &alc662_presets[board_config]);
18499
18500         spec->stream_analog_playback = &alc662_pcm_analog_playback;
18501         spec->stream_analog_capture = &alc662_pcm_analog_capture;
18502
18503         spec->stream_digital_playback = &alc662_pcm_digital_playback;
18504         spec->stream_digital_capture = &alc662_pcm_digital_capture;
18505
18506         if (!spec->adc_nids) {
18507                 spec->adc_nids = alc662_adc_nids;
18508                 spec->num_adc_nids = ARRAY_SIZE(alc662_adc_nids);
18509         }
18510         if (!spec->capsrc_nids)
18511                 spec->capsrc_nids = alc662_capsrc_nids;
18512
18513         if (!spec->cap_mixer)
18514                 set_capture_mixer(codec);
18515
18516         switch (codec->vendor_id) {
18517         case 0x10ec0662:
18518                 set_beep_amp(spec, 0x0b, 0x05, HDA_INPUT);
18519                 break;
18520         case 0x10ec0272:
18521         case 0x10ec0663:
18522         case 0x10ec0665:
18523                 set_beep_amp(spec, 0x0b, 0x04, HDA_INPUT);
18524                 break;
18525         case 0x10ec0273:
18526                 set_beep_amp(spec, 0x0b, 0x03, HDA_INPUT);
18527                 break;
18528         }
18529         spec->vmaster_nid = 0x02;
18530
18531         codec->patch_ops = alc_patch_ops;
18532         if (board_config == ALC662_AUTO)
18533                 spec->init_hook = alc662_auto_init;
18534 #ifdef CONFIG_SND_HDA_POWER_SAVE
18535         if (!spec->loopback.amplist)
18536                 spec->loopback.amplist = alc662_loopbacks;
18537 #endif
18538
18539         return 0;
18540 }
18541
18542 static int patch_alc888(struct hda_codec *codec)
18543 {
18544         if ((alc_read_coef_idx(codec, 0) & 0x00f0)==0x0030){
18545                 kfree(codec->chip_name);
18546                 codec->chip_name = kstrdup("ALC888-VD", GFP_KERNEL);
18547                 if (!codec->chip_name) {
18548                         alc_free(codec);
18549                         return -ENOMEM;
18550                 }
18551                 return patch_alc662(codec);
18552         }
18553         return patch_alc882(codec);
18554 }
18555
18556 /*
18557  * patch entries
18558  */
18559 static struct hda_codec_preset snd_hda_preset_realtek[] = {
18560         { .id = 0x10ec0260, .name = "ALC260", .patch = patch_alc260 },
18561         { .id = 0x10ec0262, .name = "ALC262", .patch = patch_alc262 },
18562         { .id = 0x10ec0267, .name = "ALC267", .patch = patch_alc268 },
18563         { .id = 0x10ec0268, .name = "ALC268", .patch = patch_alc268 },
18564         { .id = 0x10ec0269, .name = "ALC269", .patch = patch_alc269 },
18565         { .id = 0x10ec0270, .name = "ALC270", .patch = patch_alc269 },
18566         { .id = 0x10ec0272, .name = "ALC272", .patch = patch_alc662 },
18567         { .id = 0x10ec0275, .name = "ALC275", .patch = patch_alc269 },
18568         { .id = 0x10ec0861, .rev = 0x100340, .name = "ALC660",
18569           .patch = patch_alc861 },
18570         { .id = 0x10ec0660, .name = "ALC660-VD", .patch = patch_alc861vd },
18571         { .id = 0x10ec0861, .name = "ALC861", .patch = patch_alc861 },
18572         { .id = 0x10ec0862, .name = "ALC861-VD", .patch = patch_alc861vd },
18573         { .id = 0x10ec0662, .rev = 0x100002, .name = "ALC662 rev2",
18574           .patch = patch_alc882 },
18575         { .id = 0x10ec0662, .rev = 0x100101, .name = "ALC662 rev1",
18576           .patch = patch_alc662 },
18577         { .id = 0x10ec0663, .name = "ALC663", .patch = patch_alc662 },
18578         { .id = 0x10ec0665, .name = "ALC665", .patch = patch_alc662 },
18579         { .id = 0x10ec0670, .name = "ALC670", .patch = patch_alc662 },
18580         { .id = 0x10ec0880, .name = "ALC880", .patch = patch_alc880 },
18581         { .id = 0x10ec0882, .name = "ALC882", .patch = patch_alc882 },
18582         { .id = 0x10ec0883, .name = "ALC883", .patch = patch_alc882 },
18583         { .id = 0x10ec0885, .rev = 0x100101, .name = "ALC889A",
18584           .patch = patch_alc882 },
18585         { .id = 0x10ec0885, .rev = 0x100103, .name = "ALC889A",
18586           .patch = patch_alc882 },
18587         { .id = 0x10ec0885, .name = "ALC885", .patch = patch_alc882 },
18588         { .id = 0x10ec0887, .name = "ALC887", .patch = patch_alc882 },
18589         { .id = 0x10ec0888, .rev = 0x100101, .name = "ALC1200",
18590           .patch = patch_alc882 },
18591         { .id = 0x10ec0888, .name = "ALC888", .patch = patch_alc888 },
18592         { .id = 0x10ec0889, .name = "ALC889", .patch = patch_alc882 },
18593         { .id = 0x10ec0892, .name = "ALC892", .patch = patch_alc662 },
18594         {} /* terminator */
18595 };
18596
18597 MODULE_ALIAS("snd-hda-codec-id:10ec*");
18598
18599 MODULE_LICENSE("GPL");
18600 MODULE_DESCRIPTION("Realtek HD-audio codec");
18601
18602 static struct hda_codec_preset_list realtek_list = {
18603         .preset = snd_hda_preset_realtek,
18604         .owner = THIS_MODULE,
18605 };
18606
18607 static int __init patch_realtek_init(void)
18608 {
18609         return snd_hda_add_codec_preset(&realtek_list);
18610 }
18611
18612 static void __exit patch_realtek_exit(void)
18613 {
18614         snd_hda_delete_codec_preset(&realtek_list);
18615 }
18616
18617 module_init(patch_realtek_init)
18618 module_exit(patch_realtek_exit)